@danhachuel/pandanews 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.01 (2026-11-08)
+
+- **Isolamento de processos (Windows/MobaXterm)**: o backend Python roda em grupo de processos próprio (`detached: true` → `CREATE_NEW_PROCESS_GROUP`) com `windowsHide: true` (sem janela fantasma) e `stdio` em fd do arquivo — um Ctrl+C no terminal agora derruba **apenas o launcher Node**; o backend e as gerações em andamento sobrevivem
+- **Fim do processo órfão na porta 8000**: ao reabrir o app, o launcher detecta o backend vivo (`backend.pid` + probe de porta) e o **reaproveita**, em vez de subir uma segunda instância
+- **Log sem terminal**: a inicialização do uvicorn e as requisições ficam registradas em `data/backend.log` mesmo com o terminal fechado (auditoria preservada)
+- Encerramento do backend **sempre por código**: `taskkill /PID /F /T` no Windows, `kill` no grupo no Unix — sinais do terminal nunca chegam ao backend
+- `unref()` no processo filho + watchdog de saúde (polling de porta a cada 10s; 3 falhas reerguem o backend silenciosamente)
+- Teste de regressão `scripts/test-start-isolation.mjs` (`npm test`) roda no CI verificando as flags de isolamento — passo adicionado ao workflow de publish
+
 ## 0.4.00 (2026-10-30)
 
 - **Supabase opcional (Fase 6)**: detecção automática de credenciais (`SUPABASE_URL`/`SUPABASE_SERVICE_ROLE_KEY` no ambiente ou em Configurações); teste de conexão real (`POST /configuracoes/testar-supabase`); schema SQL pronto para o SQL Editor (`GET /configuracoes/schema-supabase`); migração dos dados locais SQLite → Supabase (`POST /configuracoes/migrar-supabase`) com relatório por tabela. O app continua 100% local e funcional sem Supabase

package/backend/app/main.py

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/pandanews",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "SaaS local de criação e automação de múltiplos blogs de notícias com IA (FastAPI + React + Tailwind).",
   "license": "MIT",
   "type": "module",
@@ -20,7 +20,8 @@
     "node": ">=20"
   },
   "scripts": {
-    "build:frontend": "node scripts/build.js"
+    "build:frontend": "node scripts/build.js",
+    "test": "node scripts/test-start-isolation.mjs"
   },
   "repository": {
     "type": "git",

package/scripts/start.js

@@ -3,14 +3,18 @@
 // Fluxo de um único comando: se o runtime não estiver provisionado, executa o
 // install completo (Python portátil + dependências) antes de subir os
 // servidores. Ambas as portas têm fallback automático (API: 8000, 8001, ...;
-// UI: 4030, 4031, ...). O sistema NÃO abre o navegador: o endereço é exibido
-// no terminal e o usuário decide quando abrir.
+// UI: 4030, 4031, ...). O sistema NÃO abre o navegador.
 //
-// Robustez: o output do backend é gravado em <home>/data/backend.log (completo)
-// e, se o processo morrer de forma anormal, o backend reinicia sozinho (até 5
-// vezes) — a UI não cai junto. Logs de acesso não poluem o console.
-import { createWriteStream, existsSync, readFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
+// ISOLAMENTO DE PROCESSOS (Windows/MobaXterm): o backend Python roda em grupo
+// de processos próprio (detached + windowsHide) com stdio direto no arquivo
+// <home>/data/backend.log — não herda o console do launcher. Um Ctrl+C ou
+// perda do terminal derruba apenas o launcher Node; o backend e as gerações
+// em andamento sobrevivem. O encerramento do backend é SEMPRE por código
+// (SIGTERM + taskkill /PID /T), nunca por propagação de sinal do terminal.
+// Se uma instância anterior morreu deixando backend vivo, o launcher detecta
+// (backend.pid + health) e reaproveita em vez de subir uma segunda.
+import { appendFileSync, closeSync, existsSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
 import { createServer, request as httpRequest } from 'node:http';
 import net from 'node:net';
 import { join, extname } from 'node:path';
@@ -19,14 +23,16 @@ import { resolveHome, runInstall, PKG_ROOT } from './install.js';
 const API_PORT_BASE = Number(process.env.PANDANEWS_API_PORT || 8000);
 const UI_PORT_BASE = Number(process.env.PANDANEWS_UI_PORT || 4030);
 const PORT_MAX_TRIES = 20;
-const BACKEND_MAX_RESTARTS = 5;
-const BACKEND_RESTART_DELAY_MS = 3000;
-const BACKEND_HEALTHY_UPTIME_MS = 60000;
+const BACKEND_POLL_ATTEMPTS = 60; // até 30s para o backend iniciar
+const BACKEND_POLL_MS = 500;
+const UI_POLL_ATTEMPTS = 20; // até 10s para a UI antiga responder
 
 let activeBackendPort = API_PORT_BASE;
 
 const FAVICON_URI = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Crect width='100' height='100' rx='20' fill='%230b1220'/%3E%3Ccircle cx='25' cy='28' r='13' fill='%23e6edf3'/%3E%3Ccircle cx='75' cy='28' r='13' fill='%23e6edf3'/%3E%3Ccircle cx='50' cy='52' r='30' fill='%23e6edf3'/%3E%3Cellipse cx='37' cy='48' rx='9' ry='11' fill='%230b1220' transform='rotate(-15 37 48)'/%3E%3Cellipse cx='63' cy='48' rx='9' ry='11' fill='%230b1220' transform='rotate(15 63 48)'/%3E%3Ccircle cx='38' cy='49' r='3' fill='%2322c55e'/%3E%3Ccircle cx='62' cy='49' r='3' fill='%2322c55e'/%3E%3Cellipse cx='50' cy='62' rx='5' ry='4' fill='%230b1220'/%3E%3C/svg%3E";
 
+// ---------------------------------------------------------------- utilidades
+
 function venvBin(home) {
   return process.platform === 'win32'
     ? join(home, '.runtime', 'venv', 'Scripts', 'python.exe')
@@ -44,25 +50,23 @@ const MIME = {
   '.ico': 'image/x-icon',
 };
 
-function placeholderPage() {
-  return `<!DOCTYPE html>
-<html lang="pt-BR">
-<head>
-<meta charset="utf-8">
-<title>PandaNews</title>
-<link rel="icon" href="${FAVICON_URI}">
-</head>
-<body style="font-family: Inter, system-ui, sans-serif; background: #0b1220; color: #e6edf3; display: flex; min-height: 100vh; align-items: center; justify-content: center;">
-  <div style="text-align: center;">
-    <h1 style="font-size: 3rem; margin: 0;">🐼 PandaNews</h1>
-    <p style="color: #9aa7b5;">Backend ativo em <a style="color: #22c55e;" href="/api/v1/health">/api/v1/health</a></p>
-    <p style="color: #9aa7b5;">A UI React completa chega na versão 0.2.00.</p>
-  </div>
-</body>
-</html>`;
+// Testa se uma porta aceita conexão TCP (uvicorn ouvindo).
+function portaAberta(port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: '127.0.0.1', port });
+    socket.once('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once('error', () => resolve(false));
+    socket.setTimeout(500, () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
 }
 
-// Testa se uma porta pode ser vinculada (probe real de bind).
+// Encontra a primeira porta livre a partir de base (probe real de bind).
 function probePort(port) {
   return new Promise((resolve) => {
     const srv = net.createServer();
@@ -79,6 +83,40 @@ async function findFreePort(base, maxTries) {
   throw new Error(`Nenhuma porta livre entre ${base} e ${base + maxTries - 1}`);
 }
 
+// Encerra o processo por PID e (no Windows) a árvore de processos /T.
+function encerrarPorPid(pid, motivo) {
+  try {
+    if (process.platform === 'win32') {
+      spawnSync('taskkill', ['/pid', String(pid), '/f', '/t'], { windowsHide: true });
+    } else {
+      process.kill(pid, 'SIGTERM');
+    }
+  } catch {
+      /* processo já não existia */
+  }
+  console.log(motivo);
+}
+
+// ---------------------------------------------------------- UI estática/proxy
+
+function placeholderPage() {
+  return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+<meta charset="utf-8">
+<title>PandaNews</title>
+<link rel="icon" href="${FAVICON_URI}">
+</head>
+<body style="font-family: Inter, system-ui, sans-serif; background: #0b1220; color: #e6edf3; display: flex; min-height: 100vh; align-items: center; justify-content: center;">
+  <div style="text-align: center;">
+    <h1 style="font-size: 3rem; margin: 0;">🐼 PandaNews</h1>
+    <p style="color: #9aa7b5;">Backend ativo em <a style="color: #22c55e;" href="/api/v1/health">/api/v1/health</a></p>
+    <p style="color: #9aa7b5;">A UI React completa chega na versão 0.2.00.</p>
+  </div>
+</body>
+</html>`;
+}
+
 // Encaminha /api/* para o backend FastAPI (na porta ativa).
 function proxyApi(req, res) {
   const options = {
@@ -154,62 +192,103 @@ function listenUi(port, attempt) {
   server.listen(port, '127.0.0.1', () => {
     uiServer = server;
     console.log(`PandaNews ativo em http://127.0.0.1:${port} — abra no seu navegador.`);
-    console.log('Pressione Ctrl+C para encerrar.');
+    console.log('Pressione Ctrl+C para encerrar o launcher.');
   });
 }
 
-let backendProc = null;
-let backendRestarts = 0;
+// ------------------------------------------------------- backend destacado
+
+let backendPid = null; // PID do backend que ESTA sessão iniciou (null = reaproveitado)
+
+// Descobre um backend já em execução: arquivo backend.pid + porta respondendo.
+async function backendJaRodando(home) {
+  const pidFile = join(home, 'data', 'backend.pid');
+  if (!existsSync(pidFile)) return null;
+  const pid = Number(readFileSync(pidFile, 'utf8').trim());
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  // procura o backend em qualquer porta candidata (a que gravou o pid)
+  for (let port = API_PORT_BASE; port < API_PORT_BASE + PORT_MAX_TRIES; port++) {
+    if (await portaAberta(port)) return { pid, port };
+  }
+  return null;
+}
 
-// Sobe o backend com saída completa em <home>/data/backend.log; o console
-// mantém apenas stderr (banner, erros, tracebacks). Se o processo morrer de
-// forma anormal, reinicia sozinho (até 5 tentativas).
-function startBackend(home) {
-  console.log(`Iniciando backend FastAPI em http://127.0.0.1:${activeBackendPort} ...`);
-  const uvicorn = spawn(
+async function esperarBackend(port) {
+  for (let i = 0; i < BACKEND_POLL_ATTEMPTS; i++) {
+    if (await portaAberta(port)) return true;
+    await new Promise((r) => setTimeout(r, BACKEND_POLL_MS));
+  }
+  return false;
+}
+
+// Sobe o uvicorn em grupo de processos próprio: detached (novo grupo no
+// Windows), windowsHide (sem janela preta) e stdio direto no arquivo de log.
+async function startBackend(home) {
+  const port = await findFreePort(API_PORT_BASE, PORT_MAX_TRIES);
+  if (port !== API_PORT_BASE) {
+    console.log(`Porta ${API_PORT_BASE} ocupada — backend usando ${port}.`);
+  }
+  activeBackendPort = port;
+
+  const logPath = join(home, 'data', 'backend.log');
+  const bootstrapLine = `--- ${new Date().toISOString()} — iniciando backend (porta ${port}) ---\n`;
+  appendFileSync(logPath, bootstrapLine);
+  // stdio por FD (obrigatório com detached no Windows: async forks não aceitam path)
+  const logFd = openSync(logPath, 'a');
+
+  console.log(`Iniciando backend FastAPI em http://127.0.0.1:${port} ... (log: ${logPath})`);
+  const python = spawn(
     venvBin(home),
-    ['-m', 'uvicorn', 'backend.app.main:app', '--host', '127.0.0.1', '--port', String(activeBackendPort)],
+    ['-m', 'uvicorn', 'backend.app.main:app', '--host', '127.0.0.1', '--port', String(port)],
     {
       cwd: PKG_ROOT,
-      stdio: ['inherit', 'pipe', 'pipe'],
-      env: { ...process.env, PANDANEWS_HOME: home },
+      detached: true, // CREATE_NEW_PROCESS_GROUP no Windows — imune a Ctrl+C do console
+      windowsHide: true, // sem janela de console fantasma
+      stdio: ['ignore', logFd, logFd], // saída direto no arquivo (append) — não herda console
+      env: { ...process.env, PANDANEWS_HOME: home, PYTHONUNBUFFERED: '1' },
     },
   );
-  backendProc = uvicorn;
+  closeSync(logFd); // o filho tem sua própria cópia herdada
+  python.unref(); // o launcher não morre com o backend e vice-versa
+  backendPid = python.pid ?? null;
+  if (backendPid) {
+    try {
+      writeFileSync(join(home, 'data', 'backend.pid'), String(backendPid));
+    } catch {
+      /* melhor esforço */
+    }
+  }
 
-  const logPath = join(home, 'data', 'backend.log');
-  const logStream = createWriteStream(logPath, { flags: 'a' });
-  logStream.write(`\n--- ${new Date().toISOString()} — iniciando backend (pid ${uvicorn.pid}, porta ${activeBackendPort}) ---\n`);
-  // Logs de acesso do uvicorn (stdout) vão SOMENTE para o arquivo: o terminal
-  // fica limpo. O stderr (banner, WARNING/ERROR e tracebacks) é visível.
-  uvicorn.stdout.on('data', (chunk) => {
-    logStream.write(chunk);
-  });
-  uvicorn.stderr.on('data', (chunk) => {
-    process.stderr.write(chunk);
-    logStream.write(chunk);
-  });
+  if (await esperarBackend(port)) {
+    console.log(`Backend no ar em http://127.0.0.1:${port} (sobrevive a Ctrl+C — encerrado apenas por este launcher).`);
+    return true;
+  }
+  console.error('Backend não respondeu a tempo — verifique o log completo em:');
+  console.error(`  ${logPath}`);
+  return false;
+}
 
-  const startedAt = Date.now();
-  uvicorn.on('exit', (code) => {
-    logStream.end(`--- backend encerrou com código ${code} ---\n`);
-    if (code === 0 || code === null) {
+// Watchdog de saúde: spawn destacado não emite eventos de exit confiáveis —
+// a porta é polidada a cada 10s e 3 falhas consecutivas reerguem o backend.
+let falhasSaude = 0;
+function iniciarWatchdog(home) {
+  setInterval(async () => {
+    if (await portaAberta(activeBackendPort)) {
+      falhasSaude = 0;
       return;
     }
-    if (Date.now() - startedAt > BACKEND_HEALTHY_UPTIME_MS) {
-      backendRestarts = 0; // rodou saudável por tempo suficiente: zera o contador
+    falhasSaude += 1;
+    if (falhasSaude >= 3) {
+      console.error('Backend não responde — reiniciando...');
+      falhasSaude = 0;
+      backendPid = null;
+      await startBackend(home);
     }
-    backendRestarts += 1;
-    if (backendRestarts > BACKEND_MAX_RESTARTS) {
-      console.error(`Backend caiu ${backendRestarts - 1}x seguidas — desistindo.`);
-      console.error(`Log completo do backend: ${logPath}`);
-      process.exit(1);
-    }
-    console.error(`Backend encerrou com código ${code} — reiniciando em 3s (tentativa ${backendRestarts}/${BACKEND_MAX_RESTARTS})...`);
-    setTimeout(() => startBackend(home), BACKEND_RESTART_DELAY_MS);
-  });
+  }, 10000).unref();
 }
 
+// ---------------------------------------------------------------- execução
+
 export async function runStart() {
   const home = resolveHome();
   if (!existsSync(join(home, '.runtime', '.ready'))) {
@@ -223,19 +302,49 @@ export async function runStart() {
     return;
   }
 
-  // Fallback de portas: API em 8000, 8001, ...; UI em 4030, 4031, ...
-  activeBackendPort = await findFreePort(API_PORT_BASE, PORT_MAX_TRIES);
-  if (activeBackendPort !== API_PORT_BASE) {
-    console.log(`Porta ${API_PORT_BASE} ocupada — backend usando ${activeBackendPort}.`);
+  // 1) reaproveita backend de sessão anterior (launcher morto por Ctrl+C),
+  //    eliminando o processo órfão perceptível na porta 8000
+  const existente = await backendJaRodando(home);
+  let backendOk;
+  if (existente && existente.port === Number(process.env.PANDANEWS_API_PORT || API_PORT_BASE)) {
+    console.log(`Backend já em execução (PID ${existente.pid}) — reaproveitando em http://127.0.0.1:${existente.port}.`);
+    activeBackendPort = existente.port;
+    backendOk = true;
+  } else {
+    if (existente) {
+      // backend rodando em outra porta: mantemos e deixamos nossa UI usá-la
+      console.log(`Backend já em execução (PID ${existente.pid}) na porta ${existente.port} — reaproveitando.`);
+      activeBackendPort = existente.port;
+      backendOk = true;
+    } else {
+      backendOk = await startBackend(home);
+    }
   }
 
-  startBackend(home);
+  // 2) interface
   listenUi(UI_PORT_BASE, 1);
 
-  process.on('exit', () => {
-    if (uiServer) uiServer.close();
-    if (backendProc) backendProc.kill();
+  // watchdog de saúde do backend (reergue em quedas silenciosas)
+  iniciarWatchdog(home);
+
+  // 3) sinais: encerramento SEMPRE por código, nunca por propagação do terminal
+  process.on('SIGINT', () => {
+    console.log('\nEncerrando PandaNews...');
+    if (backendPid) {
+      encerrarPorPid(backendPid, `Backend (PID ${backendPid}) encerrado — log: ${join(home, 'data', 'backend.log')}`);
+      try {
+        unlinkSync(join(home, 'data', 'backend.pid'));
+      } catch {
+        /* melhor esforço */
+      }
+    } else {
+      console.log('Backend reaproveitado de sessão anterior — segue rodando em background.');
+    }
+    process.exit(0);
   });
-  process.on('SIGINT', () => process.exit(0));
   process.on('SIGTERM', () => process.exit(0));
+
+  if (!backendOk) {
+    process.exitCode = 1;
+  }
 }

package/scripts/test-start-isolation.mjs

@@ -0,0 +1,40 @@
+// Teste de regressão do isolamento de processos do launcher (scripts/start.js).
+//
+// Falha se as flags de isolamento forem removidas: detached (novo grupo de
+// processos — imune a Ctrl+C do console no Windows), windowsHide (sem janela
+// fantasma), stdio no arquivo (backend sobrevive ao terminal), unref e o
+// arquivo backend.pid (encerramento gracioso por código).
+//
+// Roda em qualquer plataforma, inclusive no CI (Linux/ubuntu) — sem exigir o
+// runtime Python completo.
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const src = readFileSync(join(root, 'scripts', 'start.js'), 'utf8');
+
+const verificacoes = [
+  [/detached:\s*true/, 'detached: true — grupo de processos próprio (CREATE_NEW_PROCESS_GROUP no Windows)'],
+  [/windowsHide:\s*true/, 'windowsHide: true — sem janela de console fantasma'],
+  [/stdio:\s*\['ignore',\s*logFd,\s*logFd\]/, "stdio: ['ignore', logFd, logFd] — saída do backend no arquivo (fd)"],
+  [/openSync\(logPath, 'a'\)/, 'openSync do log em append (fd reaproveitado pelo filho)'],
+  [/PYTHONUNBUFFERED/, 'PYTHONUNBUFFERED=1 — logs do backend sem buffer'],
+  [/backend\.pid/, 'backend.pid — PID gravado para encerramento gracioso'],
+  [/\.unref\(\)/, 'unref() — launcher não acopla o ciclo de vida ao backend'],
+  [/taskkill/, 'encerramento no Windows via taskkill /PID /T (árvore de processos)'],
+  [/process\.kill/, 'encerramento no Unix via signal no grupo de processos'],
+];
+
+let falhas = 0;
+for (const [regex, descricao] of verificacoes) {
+  const ok = regex.test(src);
+  console.log(`${ok ? 'PASS' : 'FAIL'} — ${descricao}`);
+  if (!ok) falhas += 1;
+}
+
+if (falhas > 0) {
+  console.error(`Isolamento de processos: ${falhas} verificação(ões) falharam.`);
+  process.exit(1);
+}
+console.log('Isolamento de processos: todas as verificações passaram.');