agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/core/circuit_breaker.js

@@ -0,0 +1,546 @@
+#!/usr/bin/env node
+/**
+ * scripts/circuit_breaker.js
+ * 
+ * Circuit Breaker Inteligente Multi-Provedor para LLMs (AGDEV-9 / I-10).
+ * Abstração de resiliência e auto-cura (CLOSED, OPEN, HALF_OPEN) com fallback automático
+ * entre provedores de IA (Anthropic, OpenAI, Groq, Ollama) diante de erros HTTP 429/5xx ou timeouts.
+ */
+
+const { createSarifReport } = require('./sarif_engine.js');
+
+const STATES = {
+  CLOSED: 'CLOSED',       // Operação normal
+  OPEN: 'OPEN',           // Circuito rompido; chamadas desviadas para fallback
+  HALF_OPEN: 'HALF_OPEN'  // Sonda de teste para verificar recuperação
+};
+
+class CircuitBreaker {
+  constructor(name, options = {}) {
+    this.name = name;
+    this.failureThreshold = options.failureThreshold || 3;
+    this.recoveryTimeoutMs = options.recoveryTimeoutMs || 30000;
+    this.state = STATES.CLOSED;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.lastStateChange = Date.now();
+  }
+
+  isOpen() {
+    if (this.state === STATES.OPEN) {
+      const now = Date.now();
+      if (now - this.lastFailureTime >= this.recoveryTimeoutMs) {
+        this.state = STATES.HALF_OPEN;
+        this.lastStateChange = now;
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  recordSuccess() {
+    this.failureCount = 0;
+    this.successCount++;
+    if (this.state === STATES.HALF_OPEN) {
+      this.state = STATES.CLOSED;
+      this.lastStateChange = Date.now();
+    }
+  }
+
+  recordFailure(error) {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+
+    if (this.state === STATES.HALF_OPEN || this.failureCount >= this.failureThreshold) {
+      this.state = STATES.OPEN;
+      this.lastStateChange = Date.now();
+    }
+  }
+
+  async execute(primaryFn, fallbackFn = null) {
+    if (this.isOpen()) {
+      if (fallbackFn) {
+        return {
+          result: await fallbackFn(new Error(`Circuito ${this.name} está ABERTO (OPEN). Redirecionando para fallback.`)),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true
+        };
+      }
+      throw new Error(`Circuito ${this.name} está ABERTO (OPEN). Nenhuma chamada permitida.`);
+    }
+
+    try {
+      const result = await primaryFn();
+      this.recordSuccess();
+      return {
+        result,
+        circuit: this.name,
+        state: this.state,
+        fallbackExecuted: false
+      };
+    } catch (err) {
+      this.recordFailure(err);
+      if (fallbackFn) {
+        return {
+          result: await fallbackFn(err),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true,
+          error: err.message
+        };
+      }
+      throw err;
+    }
+  }
+
+  executeSync(primaryFn, fallbackFn = null) {
+    if (this.isOpen()) {
+      if (fallbackFn) {
+        return {
+          result: fallbackFn(new Error(`Circuito ${this.name} está ABERTO (OPEN). Redirecionando para fallback.`)),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true
+        };
+      }
+      throw new Error(`Circuito ${this.name} está ABERTO (OPEN). Nenhuma chamada permitida.`);
+    }
+
+    try {
+      const result = primaryFn();
+      this.recordSuccess();
+      return {
+        result,
+        circuit: this.name,
+        state: this.state,
+        fallbackExecuted: false
+      };
+    } catch (err) {
+      this.recordFailure(err);
+      if (fallbackFn) {
+        return {
+          result: fallbackFn(err),
+          circuit: this.name,
+          state: this.state,
+          fallbackExecuted: true,
+          error: err.message
+        };
+      }
+      throw err;
+    }
+  }
+
+  reset() {
+    this.state = STATES.CLOSED;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.lastStateChange = Date.now();
+  }
+
+  getStatus() {
+    return {
+      name: this.name,
+      state: this.state,
+      failureCount: this.failureCount,
+      failureThreshold: this.failureThreshold,
+      recoveryTimeoutMs: this.recoveryTimeoutMs,
+      isOpen: this.isOpen()
+    };
+  }
+
+  auditToSarif() {
+    const status = this.getStatus();
+    const findings = [];
+
+    if (status.isOpen) {
+      findings.push({
+        ruleId: 'RULE-CIRCUIT-OPEN',
+        name: 'CircuitBreakerTripped',
+        severity: 'HIGH',
+        message: `O circuito ${status.name} está ABERTO após ${status.failureCount} falhas consecutivas.`,
+        remediation: 'Verifique a saúde do provedor ou acione o failover automático.'
+      });
+    }
+
+    return createSarifReport({
+      toolName: `agent-master-circuit-breaker-${status.name}`,
+      rules: [
+        {
+          id: 'RULE-CIRCUIT-OPEN',
+          name: 'CircuitBreakerTripped',
+          description: 'Identifica quando um provedor de IA entrou em estado de circuito rompido',
+          severity: 'HIGH',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        circuitName: status.name,
+        state: status.state,
+        failureCount: status.failureCount
+      }
+    });
+  }
+
+  formatReport() {
+    const s = this.getStatus();
+    return [
+      `### Status do Circuito [${s.name}]`,
+      `- **Estado:** \`${s.state}\``,
+      `- **Falhas:** ${s.failureCount} / ${s.failureThreshold}`,
+      `- **Tempo de Recuperação:** ${s.recoveryTimeoutMs}ms`,
+      `- **Aberto (Bloqueado):** ${s.isOpen ? 'Sim (Failover ativo)' : 'Não (Operação normal)'}`
+    ].join('\n');
+  }
+}
+
+class MultiProviderRouter {
+  constructor(providers = ['anthropic', 'openai', 'groq', 'ollama'], options = {}) {
+    this.circuits = new Map();
+    providers.forEach(p => {
+      this.circuits.set(p, new CircuitBreaker(p, options));
+    });
+    this.providerChain = providers;
+  }
+
+  async dispatch(taskFnMap) {
+    const attempted = [];
+
+    for (const provider of this.providerChain) {
+      const circuit = this.circuits.get(provider);
+      attempted.push(provider);
+
+      if (!circuit.isOpen()) {
+        const fn = taskFnMap[provider] || taskFnMap['default'];
+        if (!fn) continue;
+
+        try {
+          const res = await circuit.execute(fn);
+          return {
+            success: true,
+            providerUsed: provider,
+            attempted,
+            result: res.result,
+            circuitStates: this.getAllStatuses()
+          };
+        } catch (err) {
+          // Erro registrado pelo circuit breaker; continua para o próximo provedor na cadeia
+          continue;
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: 'Todos os provedores de IA estão indisponíveis ou com circuito ABERTO.',
+      attempted,
+      circuitStates: this.getAllStatuses()
+    };
+  }
+
+  dispatchSync(taskFnMap) {
+    const attempted = [];
+
+    for (const provider of this.providerChain) {
+      const circuit = this.circuits.get(provider);
+      attempted.push(provider);
+
+      if (!circuit.isOpen()) {
+        const fn = taskFnMap[provider] || taskFnMap['default'];
+        if (!fn) continue;
+
+        try {
+          const res = circuit.executeSync(fn);
+          return {
+            success: true,
+            providerUsed: provider,
+            attempted,
+            result: res.result,
+            circuitStates: this.getAllStatuses()
+          };
+        } catch (err) {
+          continue;
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: 'Todos os provedores de IA estão indisponíveis ou com circuito ABERTO.',
+      attempted,
+      circuitStates: this.getAllStatuses()
+    };
+  }
+
+  async executePromptWithFailover(prompt, options = {}) {
+    const taskMap = {};
+    for (const provider of this.providerChain) {
+      taskMap[provider] = () => callLlmHttp(provider, prompt, options);
+    }
+    return this.dispatch(taskMap);
+  }
+
+  getAllStatuses() {
+    const statuses = {};
+    for (const [name, circuit] of this.circuits.entries()) {
+      statuses[name] = circuit.getStatus();
+    }
+    return statuses;
+  }
+
+  resetAll() {
+    for (const circuit of this.circuits.values()) {
+      circuit.reset();
+    }
+  }
+
+  auditToSarif() {
+    const statuses = this.getAllStatuses();
+    const findings = [];
+    const openCircuits = [];
+
+    for (const [name, st] of Object.entries(statuses)) {
+      if (st.isOpen) {
+        openCircuits.push(name);
+        findings.push({
+          ruleId: 'RULE-CIRCUIT-OPEN',
+          name: 'CircuitBreakerTripped',
+          severity: 'HIGH',
+          message: `O provedor ${name} está com o circuito ABERTO (${st.failureCount} falhas).`,
+          remediation: `Ative o failover automático para outro provedor da cadeia (${this.providerChain.join(', ')}).`
+        });
+      }
+    }
+
+    return createSarifReport({
+      toolName: 'agent-master-llm-router',
+      rules: [
+        {
+          id: 'RULE-CIRCUIT-OPEN',
+          name: 'CircuitBreakerTripped',
+          description: 'Identifica provedores LLM indisponíveis ou rompidos na cadeia de resiliência',
+          severity: 'HIGH',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        totalProviders: this.providerChain.length,
+        openCircuitsCount: openCircuits.length,
+        openCircuits
+      }
+    });
+  }
+
+  formatReport() {
+    const statuses = this.getAllStatuses();
+    const rows = Object.entries(statuses).map(([name, s]) => 
+      `| \`${name}\` | \`${s.state}\` | ${s.failureCount}/${s.failureThreshold} | ${s.isOpen ? '⚠️ Sim' : '✅ Não'} |`
+    ).join('\n');
+
+    return [
+      '### Relatório de Resiliência — Roteador Multi-Provedor LLM',
+      '| Provedor | Estado | Falhas | Circuito Aberto |',
+      '|---|---|---|---|',
+      rows
+    ].join('\n');
+  }
+}
+
+function callLlmHttp(provider, prompt, options = {}) {
+  if (options.transportAdapter) {
+    return options.transportAdapter(provider, prompt, options);
+  }
+
+  const timeoutMs = options.timeoutMs || 10000;
+
+  return new Promise((resolve, reject) => {
+    let urlStr = '';
+    const headers = { 'Content-Type': 'application/json' };
+    let payload = {};
+
+    if (provider === 'openai') {
+      const apiKey = options.openaiApiKey || process.env.OPENAI_API_KEY;
+      if (!apiKey) return reject(new Error('OPENAI_API_KEY não configurada no ambiente.'));
+      urlStr = 'https://api.openai.com/v1/chat/completions';
+      headers['Authorization'] = `Bearer ${apiKey}`;
+      payload = {
+        model: options.openaiModel || 'gpt-4o-mini',
+        messages: [{ role: 'user', content: prompt }]
+      };
+    } else if (provider === 'anthropic') {
+      const apiKey = options.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) return reject(new Error('ANTHROPIC_API_KEY não configurada no ambiente.'));
+      urlStr = 'https://api.anthropic.com/v1/messages';
+      headers['x-api-key'] = apiKey;
+      headers['anthropic-version'] = '2023-06-01';
+      payload = {
+        model: options.anthropicModel || 'claude-3-5-haiku-20241022',
+        max_tokens: 1024,
+        messages: [{ role: 'user', content: prompt }]
+      };
+    } else if (provider === 'groq') {
+      const apiKey = options.groqApiKey || process.env.GROQ_API_KEY;
+      if (!apiKey) return reject(new Error('GROQ_API_KEY não configurada no ambiente.'));
+      urlStr = 'https://api.groq.com/openai/v1/chat/completions';
+      headers['Authorization'] = `Bearer ${apiKey}`;
+      payload = {
+        model: options.groqModel || 'llama-3.3-70b-versatile',
+        messages: [{ role: 'user', content: prompt }]
+      };
+    } else if (provider === 'ollama') {
+      const host = options.ollamaHost || process.env.OLLAMA_HOST || 'http://localhost:11434';
+      urlStr = `${host.replace(/\/+$/, '')}/api/generate`;
+      payload = {
+        model: options.ollamaModel || 'llama3',
+        prompt,
+        stream: false
+      };
+    } else {
+      return reject(new Error(`Provedor desconhecido: ${provider}`));
+    }
+
+    const parsed = new URL(urlStr);
+    const transport = parsed.protocol === 'https:' ? require('node:https') : require('node:http');
+    const bodyStr = JSON.stringify(payload);
+    headers['Content-Length'] = Buffer.byteLength(bodyStr);
+
+    const req = transport.request(parsed, {
+      method: 'POST',
+      headers,
+      timeout: timeoutMs
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            const parsedRes = JSON.parse(data);
+            let textOutput = '';
+            if (provider === 'anthropic') {
+              textOutput = parsedRes.content && parsedRes.content[0] ? parsedRes.content[0].text : '';
+            } else if (provider === 'ollama') {
+              textOutput = parsedRes.response || '';
+            } else {
+              textOutput = parsedRes.choices && parsedRes.choices[0] && parsedRes.choices[0].message ? parsedRes.choices[0].message.content : '';
+            }
+            resolve({
+              provider,
+              statusCode: res.statusCode,
+              text: textOutput,
+              raw: parsedRes
+            });
+          } catch (jsonErr) {
+            resolve({ provider, statusCode: res.statusCode, text: data });
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Erro de API'} - ${data.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Timeout de conexão após ${timeoutMs}ms ao chamar ${provider}.`));
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Erro de rede no provedor ${provider}: ${err.message}`));
+    });
+
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+
+async function runCli() {
+  console.log('=== Simulação de Resiliência Multi-Provedor com Circuit Breaker (I-10) ===');
+  const router = new MultiProviderRouter(['anthropic', 'openai', 'groq', 'ollama'], { failureThreshold: 2 });
+
+  // Simula indisponibilidade em anthropic e openai
+  const taskMap = {
+    anthropic: async () => { throw new Error('HTTP 429: Too Many Requests (Rate limit exceeded)'); },
+    openai: async () => { throw new Error('HTTP 503: Service Unavailable'); },
+    groq: async () => { return 'Resposta gerada com sucesso via Groq (Llama 3.3 70B)'; },
+    ollama: async () => { return 'Resposta local via Ollama'; }
+  };
+
+  const dispatch1 = await router.dispatch(taskMap);
+  console.log('\nDespacho 1 (Anthropic & OpenAI falham -> Fallback para Groq):');
+  console.log(`Provedor Utilizado: ${dispatch1.providerUsed}`);
+  console.log(`Tentativas: ${dispatch1.attempted.join(' -> ')}`);
+  console.log(`Resultado: ${dispatch1.result}`);
+
+  console.log('\nStatus dos Circuitos:');
+  console.log(JSON.stringify(dispatch1.circuitStates, null, 2));
+}
+
+if (require.main === module) {
+  runCli().catch(console.error);
+}
+
+
+class AntiThrashingGuard {
+  constructor(options = {}) {
+    this.maxIdenticalFailures = options.maxIdenticalFailures || 2;
+    this.history = [];
+    this.thrashingTripped = false;
+  }
+
+  normalizeError(error) {
+    if (!error) return 'unknown_error';
+    const msg = typeof error === 'string' ? error : (error.message || String(error));
+    return msg
+      .replace(/:\d+:\d+/g, '')
+      .replace(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/g, '')
+      .replace(/0x[0-9a-fA-F]+/g, '')
+      .trim();
+  }
+
+  recordAttempt(error = null) {
+    if (!error) {
+      this.history = [];
+      this.thrashingTripped = false;
+      return { isThrashing: false, count: 0 };
+    }
+
+    const norm = this.normalizeError(error);
+    this.history.push({ signature: norm, timestamp: Date.now() });
+
+    if (this.history.length >= this.maxIdenticalFailures) {
+      const recent = this.history.slice(-this.maxIdenticalFailures);
+      const allIdentical = recent.every(h => h.signature === norm);
+      if (allIdentical) {
+        this.thrashingTripped = true;
+        return {
+          isThrashing: true,
+          count: this.history.length,
+          signature: norm,
+          message: `[ANTI-THRASHING FINOPS VETO]: Detectadas ${this.maxIdenticalFailures} falhas consecutivas com erro idêntico ("${norm.substring(0, 80)}..."). Execução autônoma interrompida para evitar queima descontrolada de tokens.`
+        };
+      }
+    }
+
+    return { isThrashing: false, count: this.history.length, signature: norm };
+  }
+
+  reset() {
+    this.history = [];
+    this.thrashingTripped = false;
+  }
+}
+
+
+module.exports = {
+  STATES,
+  CircuitBreaker,
+  MultiProviderRouter,
+  AntiThrashingGuard,
+  callLlmHttp
+};