@danhachuel/pandanews 0.4.3 → 0.4.5

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 Todas as versões publicadas são registradas aqui antes do publish (regra em AGENTS.md). A etiqueta visual usa PATCH de dois dígitos (ex.: 0.1.00); o registry npm normaliza para a versão canônica (ex.: 0.1.0).
 
+## 0.4.04 (2026-11-08)
+
+- **HOTFIX real — fim das janelas de CMD no instalador**: o 0.4.03 blindou apenas o launcher (`start.js`) e deixou o **caminho de instalação** descoberto. No Windows, `tar` (extração do Python portátil), `python -m venv` e `pip install -r requirements.txt` eram lançados **sem `windowsHide`** — era aí que as múltiplas janelas de terminal apareciam. Os três `spawnSync` de `scripts/install.js` agora nascem com `windowsHide: true` (`CREATE_NO_WINDOW`)
+- `scripts/build.js` blindado também: `npm install` e `npm run build` do frontend são chamados com `shell: true` (o wrapper `cmd.exe`/`npm.cmd` entra na conta) — ambos agora com `windowsHide: true`, sem piscar tela preta
+- Saída preservada: o instalador mantém `stdio: 'inherit'`, então o progresso continua visível **no console que o usuário já abriu** — só a janela extra deixa de existir (verificado empiricamente no Windows)
+- **Helper Python único e obrigatório**: `backend/core/proc.py` expõe `run_silent_process` / `run_silent` / `spawn_silent` / `call_silent` / `check_output_silent` / `system_silent`, aplicando `CREATE_NO_WINDOW = 0x08000000` via `creationflags` no Windows. O pipeline e o APScheduler rodam em memória (threads do `BackgroundScheduler`), sem processos do SO; o helper é o ponto único para qualquer subprocesso futuro
+- **Teste de regressão ampliado e validado**: `scripts/test-start-isolation.mjs` deixa de olhar só o `start.js` e passa a varrer **todos** os pontos de entrada — `start.js`, `install.js`, `build.js` e `bin/cli.js` — exigindo `windowsHide: true` em cada `spawn`/`spawnSync`/`exec`/`execSync` (inclusive quando as opções vêm de constante compartilhada, ex. `...SILENT_WINDOWS`)
+- O teste também trava regressões do backend Python: qualquer `subprocess.run/Popen/call/check_output/check_call` ou `os.system`/`os.popen` direto em `backend/**/*.py` falha o build (precisa passar por `backend.core.proc`)
+- E ainda barra `uvicorn` com `--reload`/`--workers` no launcher — cada worker é um processo filho extra que, no Windows, pode alocar console próprio e ignorar as flags do pai
+- **Guard verificado por mutação**: com a flag removida do `pip`, com um `subprocess.run` direto no backend e com `--reload` no uvicorn, o teste falha em todos os casos (exit 1) — não é carimbo de borracha
+- Nota de transparência: a colisão de versão com o 0.4.03 já publicado no registry foi resolvida por renumeração, conforme a regra de sessões simultâneas do AGENTS.md
+
+## 0.4.05 (2026-11-08)
+
+- **HOTFIX — fallback à prova de falhas no LLM Router** (crítico): roteamento reescrito em `backend/core/llm_router.py`, agora explícito provedor por provedor na ordem configurada. Qualquer erro HTTP (4xx/5xx, incluindo **404/410** da NVIDIA) é interceptado, registrado (`Modelo nvidia indisponível (Status {status}). Acionando fallback para {próximo}.`) e o próximo provedor é acionado imediatamente — a geração não trava mais. A função devolve qual provedor respondeu (`noticias.llm_provider`) e o incidente fica em `backend.log`
+- **HOTFIX — janelas de CMD na instalação**: os spawns de `tar` (extração do Python portátil), `python -m venv` e `pip install` em `scripts/install.js` nasciam sem `windowsHide` no Windows — origem das múltiplas janelas de terminal. Todos agora usam `SILENT_WINDOWS` (CREATE_NO_WINDOW), com `stdio: 'inherit'` (progresso continua visível no console que o usuário já abriu, sem janela extra). `scripts/build.js` (npm) e o helper `backend/core/proc.py` (subprocessos Python) seguem a mesma regra
+- **Teste de conexão real**: `/api/v1/llm/test` dispara POST `/chat/completions` de verdade; 404/410 devolvem estado **`degraded`** com a mensagem "Sua chave da NVIDIA retornou erro 404. O sistema usará o Gemini (fallback) para gerar as notícias."
+- Frontend: badge âmbar `degraded` no resultado do teste + tag vermelha **[Indisponível]** ao lado do select de modelos — destacada mas mantida selecionável
+- Validado em E2E com mock servers: NVIDIA → 404 → Gemini → 200 → notícia gerada com `llm_provider='google'` e logs do incidente em `backend.log`
+
 ## 0.4.03 (2026-11-08)
 
 - **Regra permanente no AGENTS.md**: é PROIBIDO criar/publicar versões que abram janelas de terminal (CMD/PowerShell/console Python) no computador do usuário — todo processo filho deve nascer com `windowsHide: true` + grupo isolado, rodar em background com saída apenas em log e ser encerrado por código; versão que exiba janela de console é inválida (hotfix + CHANGELOG)

package/backend/app/main.py

@@ -31,7 +31,7 @@ async def lifespan(_: FastAPI):
     scheduler.parar()
 
 
-app = FastAPI(title="PandaNews API", version="0.4.3", lifespan=lifespan)
+app = FastAPI(title="PandaNews API", version="0.4.5", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,

package/backend/core/llm_router.py

@@ -1,20 +1,27 @@
-"""Router de LLM do PandaNews: fallback ordenado NVIDIA NIM -> Google Gemini.
+"""Router de LLM do PandaNews: fallback ordenado e à prova de falhas.
 
-Roteamento por prioridade com llmswitch-client (circuit breaker embutido).
-O provedor que responde é devolvido junto com o texto para registrar em
-noticias.llm_provider. Teste por provedor via httpx direto no endpoint
-chat/completions (compatível com OpenAI) dos dois provedores.
+Roteamento explícito, provedor por provedor, na ordem configurada
+(padrão: NVIDIA NIM → Google Gemini). Qualquer erro HTTP do provedor atual
+(4xx/5xx — incluindo 404/410 de modelos descontinuados) é registrado e o
+próximo provedor é acionado imediatamente. A função devolve (texto, provedor)
+para registrar em noticias.llm_provider.
 """
 from __future__ import annotations
 
+import logging
 import time
 
 import httpx
+from openai import APIStatusError, OpenAI
 
 from backend.core.config import DEFAULT_LLM_BASE_URLS, DEFAULT_LLM_MODELS
 
 PROVEDORES = ("nvidia", "google")
 
+# Logger filho do uvicorn.error: mensagens vão para o backend.log (e stderr),
+# com a disciplina de logs do servidor.
+logger = logging.getLogger("uvicorn.error.pandanews")
+
 
 def get_config(db, chave: str, padrao: str = "") -> str:
     from backend.core.database import Configuracao
@@ -31,8 +38,64 @@ def provider_config(db, provider: str) -> dict:
     }
 
 
+def _chamar_provedor(db, provider: str, prompt: str, max_tokens: int) -> tuple[str, str]:
+    """Uma chamada de chat completion no provedor. Levanta em caso de erro."""
+    cfg = provider_config(db, provider)
+    client = OpenAI(api_key=cfg["api_key"], base_url=cfg["base_url"], timeout=60.0)
+    resposta = client.chat.completions.create(
+        model=cfg["model"],
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=max_tokens,
+    )
+    texto = resposta.choices[0].message.content or ""
+    modelo = str(getattr(resposta, "model", "") or cfg["model"])
+    return texto, modelo
+
+
+def gerar_texto(db, prompt: str, max_tokens: int = 1024) -> tuple[str, str]:
+    """Gera texto com fallback ordenado. Retorna (texto, provedor_que_respondeu).
+
+    Se um provedor falhar por qualquer erro HTTP, registra o incidente e
+    aciona o próximo da lista. Só levanta erro quando TODOS falham.
+    """
+    ordem = [p.strip() for p in get_config(db, "llm_fallback_ordem", "nvidia,google").split(",") if p.strip()]
+    disponiveis = [p for p in ordem if p in PROVEDORES and provider_config(db, p)["api_key"]]
+    if not disponiveis:
+        raise RuntimeError("Nenhum provedor de LLM configurado. Adicione uma API key em Configurações.")
+
+    ultimo_erro: Exception | None = None
+    for indice, provider in enumerate(disponiveis):
+        proximo = disponiveis[indice + 1] if indice + 1 < len(disponiveis) else None
+        try:
+            texto, modelo = _chamar_provedor(db, provider, prompt, max_tokens)
+            logger.info("LLM: %s respondeu (modelo %s)", provider, modelo)
+            return texto, provider
+        except APIStatusError as exc:
+            status = exc.status_code
+            ultimo_erro = exc
+            logger.warning("LLM: %s falhou com HTTP %s (%s)", provider, status, str(exc)[:300])
+            if status in (404, 410):
+                destino = proximo or "nenhum"
+                logger.warning(
+                    "Modelo %s indisponível (Status %s). Acionando fallback para %s.",
+                    provider,
+                    status,
+                    destino,
+                )
+        except Exception as exc:  # noqa: BLE001 — timeouts, rede, auth: tenta o próximo
+            ultimo_erro = exc
+            logger.warning("LLM: %s falhou (%s): %s", provider, type(exc).__name__, str(exc)[:300])
+        if proximo:
+            continue
+    raise RuntimeError(f"Todos os provedores de LLM falharam ({', '.join(disponiveis)}). Último erro: {ultimo_erro}")
+
+
 def test_provider(db, provider: str) -> dict:
-    """Ping real ao endpoint chat/completions do provedor (1 token)."""
+    """Chamada real e curta (POST /chat/completions) para validar a chave.
+
+    404/410 → 'degraded': a chave pode funcionar, mas o modelo endpoint está
+    indisponível — o pipeline segue pelo fallback. A UI distingue os estados.
+    """
     if provider not in PROVEDORES:
         return {"ok": False, "detail": f"Provedor desconhecido: {provider}"}
     cfg = provider_config(db, provider)
@@ -51,41 +114,18 @@ def test_provider(db, provider: str) -> dict:
         elapsed_ms = int((time.perf_counter() - started) * 1000)
         if resp.status_code == 200:
             return {"ok": True, "status": 200, "latency_ms": elapsed_ms, "model": cfg["model"], "base_url": cfg["base_url"]}
+        if resp.status_code in (404, 410):
+            return {
+                "ok": False,
+                "degraded": True,
+                "status": resp.status_code,
+                "detail": (
+                    f"Sua chave da NVIDIA retornou erro {resp.status_code}. "
+                    "O sistema usará o Gemini (fallback) para gerar as notícias."
+                    if provider == "nvidia"
+                    else f"Endpoint do Gemini retornou {resp.status_code}. O sistema usará a NVIDIA (primário) para gerar as notícias."
+                ),
+            }
         return {"ok": False, "status": resp.status_code, "detail": resp.text[:400]}
     except Exception as exc:  # noqa: BLE001
         return {"ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-
-
-def gerar_texto(db, prompt: str, max_tokens: int = 1024) -> tuple[str, str]:
-    """Gera texto com fallback ordenado. Retorna (texto, provedor_que_respondeu)."""
-    from llmswitch import Client, Endpoint, LLMSwitchConfig
-
-    ordem = [p.strip() for p in get_config(db, "llm_fallback_ordem", "nvidia,google").split(",") if p.strip()]
-    endpoints = []
-    for provider in ordem:
-        if provider not in PROVEDORES:
-            continue
-        cfg = provider_config(db, provider)
-        if cfg["api_key"]:
-            endpoints.append(
-                Endpoint(provider=provider, base_url=cfg["base_url"], api_key=cfg["api_key"], model=cfg["model"])
-            )
-    if not endpoints:
-        raise RuntimeError("Nenhum provedor de LLM configurado. Adicione uma API key em Configurações.")
-
-    config = LLMSwitchConfig(alias="pandanews", endpoints=endpoints)
-    client = Client(configs=config)
-    resp = client.chat.completions.create(
-        model="pandanews",
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-    )
-    texto = resp.choices[0].message.content or ""
-    model = getattr(resp, "model", "") or ""
-    if "llama" in model or "nvidia" in model:
-        provedor = "nvidia"
-    elif "gemini" in model:
-        provedor = "google"
-    else:
-        provedor = endpoints[0].provider if endpoints else "desconhecido"
-    return texto, provedor

package/backend/core/proc.py

@@ -0,0 +1,89 @@
+"""Processos filhos silenciosos (regra permanente do AGENTS.md).
+
+O PandaNews NUNCA pode abrir janelas de terminal (CMD, PowerShell, console
+Python) no computador do usuário. No Windows, todo processo filho precisa da
+flag ``CREATE_NO_WINDOW`` (0x08000000); sem ela, qualquer ``subprocess`` ou
+gerador de console aloca uma tela preta.
+
+Este módulo é o ÚNICO ponto de entrada autorizado para subprocessos no
+backend. Nunca chame ``subprocess.run``/``subprocess.Popen``/``subprocess.call``
+nem ``os.system`` diretamente — use ``run_silent_process``/``run_silent``/
+``spawn_silent``. O teste ``scripts/test-start-isolation.mjs`` (rodado no CI)
+falha o build se encontrar uma chamada direta em ``backend/**/*.py``.
+
+Exemplos::
+
+    from backend.core.proc import run_silent_process, spawn_silent
+
+    # execução síncrona
+    run_silent_process(["ffmpeg", "-version"], check=True, capture_output=True)
+
+    # execução assíncrona (não bloqueia o event loop)
+    proc = spawn_silent(["pandoc", "--version"])
+    proc.wait()
+
+O pipeline de notícias e o APScheduler rodam em memória (threads do
+``BackgroundScheduler``), sem processos do sistema operacional — este módulo
+só é necessário quando uma ferramenta externa realmente precisa ser chamada.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+
+# Flag do Windows: o processo nasce sem console, portanto sem janela visível.
+# Ver https://learn.microsoft.com/windows/win32/procthread/process-creation-flags
+CREATE_NO_WINDOW = 0x08000000
+
+
+def silent_kwargs(kwargs: dict | None = None) -> dict:
+    """Devolve as opções de subprocesso com a flag de ocultação aplicada.
+
+    Em Windows adiciona ``creationflags=CREATE_NO_WINDOW``; nas demais
+    plataformas não há console novo a ocultar, então as opções passam
+    intactas. Nunca use ``shell=True`` junto a este helper.
+    """
+    opts = dict(kwargs or {})
+    if sys.platform == "win32":
+        opts["creationflags"] = CREATE_NO_WINDOW
+    return opts
+
+
+def run_silent_process(cmd_args, **kwargs):
+    """Substitui ``subprocess.run`` — sem janela de console no Windows."""
+    return subprocess.run(cmd_args, **silent_kwargs(kwargs))
+
+
+# Alias: mesma semântica, nome curto para uso interno.
+run_silent = run_silent_process
+
+
+def spawn_silent(cmd_args, **kwargs):
+    """Substitui ``subprocess.Popen`` — sem janela de console no Windows."""
+    return subprocess.Popen(cmd_args, **silent_kwargs(kwargs))
+
+
+def call_silent(cmd_args, **kwargs):
+    """Substitui ``subprocess.call`` — sem janela de console no Windows."""
+    return subprocess.call(cmd_args, **silent_kwargs(kwargs))
+
+
+def check_output_silent(cmd_args, **kwargs):
+    """Substitui ``subprocess.check_output`` — sem janela de console no Windows."""
+    return subprocess.check_output(cmd_args, **silent_kwargs(kwargs))
+
+
+def system_silent(cmd: str) -> int:
+    """Substitui ``os.system`` sem abrir shell visível.
+
+    ``os.system`` sempre passa por ``cmd.exe``/``/bin/sh`` e herda o console;
+    quando não há alternativa, a chamada é feita pelo helper silencioso.
+    """
+    if sys.platform == "win32":
+        proc = subprocess.run(
+            cmd,
+            shell=True,
+            creationflags=CREATE_NO_WINDOW,
+        )
+        return proc.returncode
+    return subprocess.call(cmd, shell=True)