unify logs under custom logger

src/agents/auditor/agent.ts

@@ -57,7 +57,7 @@ const walkDirectory = (dir: string, depth: number, solFiles: string[], docFiles:
 };
 
 const defineScope: GraphNode<typeof AuditorState> = async (state) => {
-  logger.info(`defineScope: walking repo at ${state.repoPath}`);
+  logger.info(`[Auditor] defineScope: percorrendo repositório em ${state.repoPath}`);
 
   const solFiles: string[] = [];
   const docFiles: string[] = [];
@@ -66,16 +66,16 @@ const defineScope: GraphNode<typeof AuditorState> = async (state) => {
 
   const fileTree = buildRepoTree(state.repoPath);
 
-  logger.info(`defineScope: found ${solFiles.length} Solidity file(s), ${docFiles.length} doc file(s)`);
-  logger.debug(`defineScope: Solidity files: ${JSON.stringify(solFiles)}`);
-  logger.debug(`defineScope: doc files: ${JSON.stringify(docFiles)}`);
-  logger.debug(`defineScope: file tree:\n${fileTree}`);
+  logger.info(`[Auditor] defineScope: encontrado(s) ${solFiles.length} arquivo(s) Solidity e ${docFiles.length} arquivo(s) de documentação`);
+  logger.debug(`[Auditor] defineScope: arquivos Solidity: ${JSON.stringify(solFiles)}`);
+  logger.debug(`[Auditor] defineScope: arquivos de documentação: ${JSON.stringify(docFiles)}`);
+  logger.debug(`[Auditor] defineScope: árvore de arquivos:\n${fileTree}`);
 
   return { scope: solFiles, docs: docFiles, fileTree };
 };
 
 const gatherContext: GraphNode<typeof AuditorState> = async (state) => {
-  logger.info(`gatherContext: processing ${state.scope.length} Solidity file(s) and ${state.docs.length} doc file(s)`);
+  logger.info(`[Auditor] gatherContext: processando ${state.scope.length} arquivo(s) Solidity e ${state.docs.length} arquivo(s) de documentação`);
 
   const readFile = (filePath: string): string => {
     try {
@@ -124,8 +124,8 @@ const gatherContext: GraphNode<typeof AuditorState> = async (state) => {
   const model = llm.withStructuredOutput(z.object({ context: z.string() }));
   const result = await model.invoke([new SystemMessage(GATHER_CONTEXT_PROMPT), new HumanMessage(parts.join("\n\n"))]);
 
-  logger.info(`gatherContext: context built (${parts.join("\n\n").length} chars)`);
-  logger.debug(`gatherContext: full context:\n${parts.join("\n\n")}`);
+  logger.info(`[Auditor] gatherContext: contexto construído (${parts.join("\n\n").length} caracteres)`);
+  logger.debug(`[Auditor] gatherContext: contexto completo:\n${parts.join("\n\n")}`);
 
   return { repoContext: result.context };
 };
@@ -144,7 +144,7 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
       : null;
 
   logger.info(
-    `findVulnerabilities: invoking LLM for ${state.scope.length} file(s) in parallel (iteration ${state.reflectionCount + 1})`,
+    `[Auditor] findVulnerabilities: invocando LLM para ${state.scope.length} arquivo(s) em paralelo (iteração ${state.reflectionCount + 1})`,
   );
 
   const allFindings = await Promise.all(
@@ -162,7 +162,7 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
         userMessage += `\n\nJudge feedback from previous iteration (iteration ${state.reflectionCount}):\n${previousFeedback}\n\nRevise your findings accordingly.`;
       }
 
-      logger.debug(`findVulnerabilities: processing ${filePath}`);
+      logger.debug(`[Auditor] findVulnerabilities: processando ${filePath}`);
 
       const result = await model.invoke([
         new SystemMessage(FIND_VULNERABILITIES_PROMPT),
@@ -178,15 +178,15 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
   );
 
   const candidateFindings = allFindings.flat();
-  logger.info(`findVulnerabilities: LLM returned ${candidateFindings.length} total candidate finding(s)`);
-  logger.debug(`findVulnerabilities: findings:\n${JSON.stringify(candidateFindings, null, 2)}`);
+  logger.info(`[Auditor] findVulnerabilities: LLM retornou ${candidateFindings.length} finding(s) candidato(s) no total`);
+  logger.debug(`[Auditor] findVulnerabilities: findings:\n${JSON.stringify(candidateFindings, null, 2)}`);
 
   return { candidateFindings };
 };
 
 const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
   if (state.candidateFindings.length === 0) {
-    logger.info("judgeFindings: no candidate findings to review, skipping LLM call");
+    logger.info("[Auditor] judgeFindings: sem findings candidatos para revisar, pulando chamada ao LLM");
     return {
       judgeReviews: [],
       findings: [],
@@ -196,7 +196,7 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
 
   const model = llm.withStructuredOutput(JudgeReviewSchema);
 
-  logger.info(`judgeFindings: reviewing ${state.candidateFindings.length} candidate finding(s) in parallel`);
+  logger.info(`[Auditor] judgeFindings: revisando ${state.candidateFindings.length} finding(s) candidato(s) em paralelo`);
 
   const reviews = await Promise.all(
     state.candidateFindings.map(async (finding, i) => {
@@ -209,7 +209,7 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
 
       const findingText = `[Finding ${i + 1}] ${finding.title}\nSeverity: ${finding.severity}\nDescription: ${finding.description}\nLocation: ${finding.path} lines ${finding.location}\nCode:\n\`\`\`solidity\n${finding.codeSnippet}\n\`\`\``;
 
-      logger.debug(`judgeFindings: reviewing finding ${i + 1}: ${finding.title}`);
+      logger.debug(`[Auditor] judgeFindings: revisando finding ${i + 1}: ${finding.title}`);
       return model.invoke([
         new SystemMessage(JUDGE_FINDINGS_PROMPT),
         new HumanMessage(
@@ -234,8 +234,8 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
 
   const falsePositiveCount = state.candidateFindings.length - findings.length;
 
-  logger.info(`judgeFindings: ${findings.length} confirmed, ${falsePositiveCount} false positive(s)`);
-  logger.debug(`judgeFindings: reviews:\n${JSON.stringify(reviews, null, 2)}`);
+  logger.info(`[Auditor] judgeFindings: ${findings.length} confirmado(s), ${falsePositiveCount} falso(s) positivo(s)`);
+  logger.debug(`[Auditor] judgeFindings: revisões:\n${JSON.stringify(reviews, null, 2)}`);
 
   return {
     judgeReviews: reviews,

src/agents/tester/agent.ts

@@ -1,25 +1,26 @@
-import "dotenv/config";
 import { StateGraph, END, START } from "@langchain/langgraph";
-import { PoCStateAnnotation, PoCState } from "./state.js";
+
+import { PoCStateAnnotation, type PoCState } from "./state.js";
 import { generateLocalScaffold } from "./tools/scaffoldGenerator.js";
-import { OracleContext } from "./types.js";
+import type { OracleContext } from "./types.js";
 import { createLLM } from "../../config/llm.ts";
 import { SYSTEM_PROMPT } from "./prompts/system.js";
 import { extractSolidity } from "./utils/extractSolidity.js";
 import { runFoundry } from "./tools/foundryRunner.js";
 import { analyzeFoundryLog } from "./utils/logAnalyzer.js";
+import { logger } from "../../logger.ts";
 
 const MAX_ITERATIONS = 5;
 
 const llm = createLLM();
 
 async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[oracleNode] gerando scaffold para:", state.report.title);
+  logger.info(`[Tester] oracleNode: gerando scaffold para: ${state.report.title}`);
 
   const solidityScaffold = generateLocalScaffold(state.report);
   const oracleContext: OracleContext = { solidityScaffold };
 
-  console.log("[oracleNode] scaffold gerado, tamanho:", solidityScaffold.length, "chars");
+  logger.info(`[Tester] oracleNode: scaffold gerado, tamanho: ${solidityScaffold.length} chars`);
   return { oracleContext };
 }
 
@@ -53,7 +54,7 @@ Scaffold (complete APENAS test_Exploit):
 ${oracleContext!.solidityScaffold}
 \`\`\``;
 
-  console.log(`[testerAgent] generatePoCNode iteração ${iterations + 1}, isRetry=${isRetry}`);
+  logger.info(`[Tester] generatePoCNode: iteração ${iterations + 1}, isRetry=${isRetry}`);
 
   try {
     const response = await llm.invoke([
@@ -61,16 +62,16 @@ ${oracleContext!.solidityScaffold}
       { role: "user", content: userMessage },
     ]);
     const solidityCode = extractSolidity(response.content as string);
-    console.log("[testerAgent] Solidity extraído, tamanho:", solidityCode.length);
+    logger.info(`[Tester] generatePoCNode: Solidity extraído, tamanho: ${solidityCode.length}`);
     return { pocCode: solidityCode, iterations: 1 };
   } catch (err) {
-    console.error("[testerAgent] falha na geração:", (err as Error).message);
+    logger.error(`[Tester] generatePoCNode: falha na geração: ${(err as Error).message}`);
     return { iterations: 1, lastError: `Erro na geração/extração: ${(err as Error).message}` };
   }
 }
 
 async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[testerAgent] Executando runFoundryNode...");
+  logger.info("[Tester] runFoundryNode: executando...");
 
   const trimmedCode = state.pocCode.trim();
   const isMissingCode = trimmedCode.length === 0;
@@ -78,14 +79,15 @@ async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
   const isMissingTest = !trimmedCode.includes("function test_Exploit()");
   const isPlaceholder = trimmedCode.includes("TODO: implementar exploit");
   if (isMissingCode || isMissingContract || isMissingTest || isPlaceholder) {
-    const summary = state.lastError ?? (isMissingCode
-      ? "Código Solidity ausente. O LLM não retornou o arquivo do exploit."
-      : isMissingContract
-        ? "Contrato ExploitTest não encontrado no arquivo."
-        : isMissingTest
-          ? "Função test_Exploit() não encontrada no arquivo."
-          : "Exploit não implementado (placeholder TODO ainda presente)."
-    );
+    const summary =
+      state.lastError ??
+      (isMissingCode
+        ? "Código Solidity ausente. O LLM não retornou o arquivo do exploit."
+        : isMissingContract
+          ? "Contrato ExploitTest não encontrado no arquivo."
+          : isMissingTest
+            ? "Função test_Exploit() não encontrada no arquivo."
+            : "Exploit não implementado (placeholder TODO ainda presente).");
     const status = state.iterations >= MAX_ITERATIONS ? "failed" : "running";
     return {
       executionLogs: [summary],
@@ -94,30 +96,24 @@ async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
     };
   }
 
-  const result   = await runFoundry(state.pocCode);
+  const result = await runFoundry(state.pocCode);
   const analysis = analyzeFoundryLog(result);
   const noTestsFound = result.combined.includes("No tests found");
   const summary = noTestsFound
     ? "Forge não encontrou nenhum teste. Verifique se o contrato se chama ExploitTest e se existe test_Exploit()."
     : analysis.summary;
-  const passed   = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
+  const passed = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
   const isLastAttempt = state.iterations >= MAX_ITERATIONS;
 
-  const status = passed
-    ? "success"
-    : result.timedOut
-      ? "timeout"
-      : isLastAttempt
-        ? "failed"
-        : "running";
+  const status = passed ? "success" : result.timedOut ? "timeout" : isLastAttempt ? "failed" : "running";
 
-  console.log(`[testerAgent] Resultado Foundry: exitCode=${result.exitCode}, passed=${passed}`);
+  logger.info(`[Tester] runFoundryNode: resultado Foundry: exitCode=${result.exitCode}, passed=${passed}`);
   if (!passed) {
-    console.log(`[testerAgent] Falha detectada: ${analysis.summary}`);
+    logger.info(`[Tester] runFoundryNode: falha detectada: ${analysis.summary}`);
   }
 
   return {
-    executionLogs: [result.combined],   // reducer append
+    executionLogs: [result.combined], // reducer append
     lastError: summary,
     status,
   };
@@ -130,14 +126,17 @@ async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
   }
 
   const mockResult = {
-    exitCode: 1, timedOut: lastLog.includes("TIMEOUT"),
-    stdout: "", stderr: "", combined: lastLog,
+    exitCode: 1,
+    timedOut: lastLog.includes("TIMEOUT"),
+    stdout: "",
+    stderr: "",
+    combined: lastLog,
   };
 
   const analysis = analyzeFoundryLog(mockResult as any);
 
-  console.log(`[reflectNode] categoria: ${analysis.category}`);
-  console.log(`[reflectNode] resumo: ${analysis.summary}`);
+  logger.info(`[Tester] reflectNode: categoria: ${analysis.category}`);
+  logger.info(`[Tester] reflectNode: resumo: ${analysis.summary}`);
 
   return {
     lastError: `[${analysis.category.toUpperCase()}] ${analysis.summary}\n\nLinhas relevantes:\n${analysis.relevantLines.join("\n")}`,

src/agents/tester/index.ts

@@ -1,5 +1,6 @@
 import { testerAgent } from "./agent.js";
 import { VulnerabilityReport, PoCResult } from "./types.js";
+import { logger } from "../../logger.js";
 
 /**
  * Entry point para o Agente Gerador de PoCs.
@@ -7,19 +8,19 @@ import { VulnerabilityReport, PoCResult } from "./types.js";
  * @returns PoCResult contendo o código do exploit e o status da execução.
  */
 export async function runPoCGenerator(report: VulnerabilityReport): Promise<PoCResult> {
-  console.log(`[runPoCGenerator] Iniciando para: ${report.id} — ${report.title}`);
+  logger.info(`[Tester] runPoCGenerator: iniciando para: ${report.id} — ${report.title}`);
 
   const finalState = await testerAgent.invoke({ report });
 
   const result: PoCResult = {
-    reportId:      report.id,
-    status:        finalState.status === "running" ? "failed" : finalState.status,
-    solidityCode:  finalState.pocCode,
+    reportId: report.id,
+    status: finalState.status === "running" ? "failed" : finalState.status,
+    solidityCode: finalState.pocCode,
     executionLogs: finalState.executionLogs,
-    iterations:    finalState.iterations,
+    iterations: finalState.iterations,
   };
 
-  console.log(`[runPoCGenerator] Concluído — status=${result.status}, iterações=${result.iterations}`);
+  logger.info(`[Tester] runPoCGenerator: concluído — status=${result.status}, iterações=${result.iterations}`);
   return result;
 }
 

src/agents/tester/tools/foundryRunner.ts

@@ -3,7 +3,9 @@ import { promisify } from "util";
 import { writeFile, access } from "fs/promises";
 import { join } from "path";
 
-const execAsync  = promisify(exec);
+import { logger } from "../../../logger.js";
+
+const execAsync = promisify(exec);
 const SANDBOX = process.env.SANDBOX_DIR || "/tmp/poc-sandbox";
 const TIMEOUT_MS = 60_000;
 
@@ -22,7 +24,7 @@ async function ensureSandbox() {
   try {
     await access(join(SANDBOX, "foundry.toml"));
   } catch {
-    console.log("[foundryRunner] Sandbox não encontrado. Inicializando...");
+    logger.info("[Tester] foundryRunner: sandbox não encontrado, inicializando...");
     // Caminho absoluto para o script de setup (assume execução da raiz do projeto)
     await execAsync("./scripts/setup-sandbox.sh");
   }
@@ -30,19 +32,16 @@ async function ensureSandbox() {
 
 export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
   await ensureSandbox();
-  
+
   // Escrever o arquivo no sandbox
   await writeFile(`${SANDBOX}/test/Exploit.t.sol`, solidityCode, "utf-8");
 
   try {
-    const { stdout, stderr } = await execAsync(
-      "forge test --match-contract ExploitTest -vvvv",
-      { 
-        cwd: SANDBOX, 
-        timeout: TIMEOUT_MS, 
-        env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` } 
-      }
-    );
+    const { stdout, stderr } = await execAsync("forge test --match-contract ExploitTest -vvvv", {
+      cwd: SANDBOX,
+      timeout: TIMEOUT_MS,
+      env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` },
+    });
     return {
       exitCode: 0,
       stdout,
@@ -53,7 +52,9 @@ export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
   } catch (err: any) {
     if (err.killed || err.signal === "SIGTERM") {
       return {
-        exitCode: -1, stdout: "", stderr: "Forge timed out",
+        exitCode: -1,
+        stdout: "",
+        stderr: "Forge timed out",
         combined: `TIMEOUT após ${TIMEOUT_MS / 1000}s`,
         timedOut: true,
       };

src/config/llm.ts

@@ -16,8 +16,6 @@ export function createLLM(overrideProvider?: LLMProvider): BaseChatModel {
         apiKey: process.env.OPENROUTER_API_KEY,
         maxTokens: 4096,
       });
-
-
     case "anthropic":
       return new ChatAnthropic({
         model: process.env.ANTHROPIC_MODEL || "claude-sonnet-4-6",

src/logger.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { Writable } from "node:stream";
 
 import winston from "winston";
 
@@ -15,6 +16,27 @@ const lineFormat = printf(({ level, message, timestamp: ts, stack }) => {
   return stack ? `${base}\n${stack}` : base;
 });
 
+type LogSink = (message: string) => void | Promise<void>;
+
+let activeSink: LogSink | null = null;
+
+export function setLogSink(sink: LogSink): void {
+  activeSink = sink;
+}
+
+export function clearLogSink(): void {
+  activeSink = null;
+}
+
+const sinkStream = new Writable({
+  write(chunk: Buffer, _encoding: string, callback: () => void) {
+    if (activeSink) {
+      void activeSink(chunk.toString().trim());
+    }
+    callback();
+  },
+});
+
 export const logger = winston.createLogger({
   level: "debug",
   transports: [
@@ -25,5 +47,10 @@ export const logger = winston.createLogger({
       filename: path.join(logsDir, `app-${runTimestamp}.log`),
       format: combine(timestamp(), errors({ stack: true }), lineFormat),
     }),
+    new winston.transports.Stream({
+      stream: sinkStream,
+      level: "info",
+      format: winston.format.printf(({ message }) => String(message)),
+    }),
   ],
 });

src/server.ts

@@ -13,6 +13,7 @@ import { coderAgent } from "./agents/coder/agent.ts";
 import { auditorAgent } from "./agents/auditor/agent.ts";
 import { testerAgent } from "./agents/tester/agent.ts";
 import { mapFindingToReport } from "./utils/mapFinding.js";
+import { logger, setLogSink, clearLogSink } from "./logger.ts";
 
 const app = new Hono();
 
@@ -35,16 +36,16 @@ app.post("/api/run", (c) => {
     };
 
     try {
+      setLogSink((msg) => send("log", msg));
+
       // === CODER ===
-      await send("log", "[Coder] Gerando smart contract a partir dos requisitos...");
+      logger.info("[Coder] Gerando smart contract a partir dos requisitos...");
       const coderResult = await coderAgent.invoke({ requirements: [requirements] });
 
-      await send("log", "[Coder] Contrato gerado com sucesso.");
-
       if (coderResult.compilationErrors.length > 0) {
-        await send("log", `[Coder] Erros de compilação restantes: ${coderResult.compilationErrors.length}`);
+        logger.info(`[Coder] Erros de compilação restantes: ${coderResult.compilationErrors.length}`);
       } else {
-        await send("log", "[Coder] Contrato compilado sem erros.");
+        logger.info("[Coder] Contrato compilado sem erros.");
       }
 
       await send(
@@ -62,11 +63,11 @@ app.post("/api/run", (c) => {
       writeFileSync(resolve(outputDir, "Contract.sol"), coderResult.contract, "utf-8");
       writeFileSync(resolve(outputDir, "README.md"), requirements, "utf-8");
 
-      await send("log", "[Auditor] Iniciando auditoria de segurança...");
+      logger.info("[Auditor] Iniciando auditoria de segurança...");
       const auditorResult = await auditorAgent.invoke({ repoPath: outputDir });
-      await send("log", `[Auditor] ${auditorResult.findings.length} vulnerabilidade(s) encontrada(s).`);
+      logger.info(`[Auditor] ${auditorResult.findings.length} vulnerabilidade(s) encontrada(s).`);
       for (const f of auditorResult.findings) {
-        await send("log", `[Auditor] [${f.severity.toUpperCase()}] ${f.title} — ${f.location}`);
+        logger.info(`[Auditor] [${f.severity.toUpperCase()}] ${f.title} — ${f.location}`);
       }
 
       await send(
@@ -77,14 +78,14 @@ app.post("/api/run", (c) => {
       );
 
       // === TESTER ===
-      await send("log", "[Tester] Gerando testes de prova de conceito...");
+      logger.info("[Tester] Gerando testes de prova de conceito...");
 
       if (auditorResult.findings.length > 0) {
         const report = mapFindingToReport(auditorResult.findings[0], coderResult.contract);
         const testerResult = await testerAgent.invoke({ report });
 
-        await send("log", `[Tester] Execução concluída com status: ${testerResult.status}`);
-        
+        logger.info(`[Tester] Execução concluída com status: ${testerResult.status}`);
+
         // Garante que o objeto enviado tem exatamente o que o front espera
         await send(
           "tester",
@@ -96,15 +97,17 @@ app.post("/api/run", (c) => {
           }),
         );
       } else {
-        await send("log", "[Tester] Nenhuma vulnerabilidade para testar.");
+        logger.info("[Tester] Nenhuma vulnerabilidade para testar.");
         await send("tester", JSON.stringify({ status: "skipped", iterations: 0 }));
       }
 
-      await send("log", "Pipeline concluído.");
+      logger.info("Pipeline concluído.");
       await send("done", "ok");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       await send("error", message);
+    } finally {
+      clearLogSink();
     }
   });
 });