sagadeck 1.11.4 → 1.11.5

package/bin/sagadeck.js

@@ -414,6 +414,8 @@ async function main() {
         console.error(`A porta ${port} está ocupada por outro programa. Use --port=OUTRA.`);
         process.exit(1);
       });
+      // SIGTERM do systemd ao reiniciar: sai em segundos, sem esperar o SIGKILL (src/studio/shutdown.js)
+      (await import("../src/studio/shutdown.js")).installShutdown(server);
       server.listen(port, host, async () => {
         const { studioBanner } = await import("../src/studio/banner.js");
         for (const line of studioBanner({ version: VERSION, url: `http://${shownHost}:${port}/`, library, ai: (await import("../src/ai/llm.js")).llmConfig(), multiuser, usersDir: path.join(library, "usuarios"), isLibrary: !deckFile })) console.log(line);

package/docs/ANDAMENTO.md

@@ -8,6 +8,24 @@ começar. Trabalho em curso vai para o GitHub (commit + push) a cada etapa, nunc
 
 ---
 
+## 1.11.5: parada do servidor, biblioteca no OneDrive — 23/10/2026 (branch `claude/parada-e-fotos`)
+
+- **Parada**: o Playwright, ao abrir o Chrome, instala um tratador de SIGTERM que só fecha o navegador; com ele, o
+  Node não sai mais sozinho. No Oracle, cada reinício ficava 90 s fora do ar até o SIGKILL (o log de toda semana:
+  "Failed with result 'timeout'"). `src/studio/shutdown.js`: SIGTERM/SIGHUP param de aceitar conexões, dão 8 s para
+  as que estão em uso, cortam o resto, fecham o Chrome das miniaturas e saem. Teste: `test/studio-shutdown.test.js`
+  (o prazo; e o Studio de verdade, depois de abrir o Chrome, sai em segundos com SIGTERM; só no Linux, porque no
+  Windows o SIGTERM mata na hora). Conferido no Oracle: sem a correção, não saiu em 15 s; com ela, saiu em 2 s.
+- **Biblioteca no OneDrive**: a listagem lia e interpretava o YAML de todas as apresentações a cada abertura (com
+  "arquivos só na nuvem", isso baixa cada uma). Agora guarda título, slides, tema e avisos pela data, tamanho e inode
+  do `.yaml` e do relatório de avisos, em memória e em `lista.json` no cache. Teste: `library.test.js` (nenhum
+  `.yaml` relido sem mudança, nem depois de reiniciar; só o que mudou; apagado some; cache estragado não quebra).
+- **Cache fora da nuvem**: `libraryCacheDir` põe capas, vitrine e lista em `%LOCALAPPDATA%\sagadeck\cache\<biblioteca>`
+  quando a biblioteca está dentro do OneDrive (variáveis `OneDrive`, `OneDriveCommercial`, `OneDriveConsumer`); o
+  `.cache` antigo de dentro dela sai (só `capas`, `vitrine` e `lista.json`). Fora do OneDrive e no servidor, nada muda.
+- **Fotos da transformação, medido e deixado como está**: cada foto custa ~0,4 s e o lote tem no máximo 5 slides;
+  abrir o deck uma vez por lote pouparia ~10 s numa transformação de 40 slides, que leva minutos de IA.
+
 ## 1.11.4: CI mais rápida, implantação por roteiro, diário em dia — 23/10/2026 (branch `claude/melhorias-infra`)
 
 - **Antivírus do Windows segurava a abertura do deck** (exportação, fotos, PDF, PPTX e conferência): o Node lia o

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sagadeck",
-  "version": "1.11.4",
+  "version": "1.11.5",
   "description": "Gerador de apresentações: YAML -> HTML animado + PowerPoint editável, com temas e figuras geradas na hora.",
   "type": "module",
   "bin": {

package/src/library.js

@@ -10,9 +10,10 @@
 //     rascunho.yaml                   .yaml solto na raiz = apresentação sem tópico
 // Na raiz, pasta é SEMPRE tópico. "Nova sem tópico" vai para "Sem tópico"; importar sem tópico, para "Importados".
 //     .lixeira/                       excluídas (1 dia), com .origem.json
-//     .cache/                         capas geradas
+//     .cache/                         capas geradas e lista (no OneDrive, fica fora: libraryCacheDir)
 //
 // O id de uma apresentação é o caminho do .yaml dela, relativo à biblioteca, com "/" (ex.: "Palestras/X/X.yaml").
+import crypto from "node:crypto";
 import fs from "node:fs";
 import { renameRetry, copyRetry, removeRetry } from "./fs-retry.js";
 import os from "node:os";
@@ -69,6 +70,20 @@ export function defaultLibraryRoot(env = process.env, { platform = process.platf
   return path.resolve(target);
 }
 
+// Cache do que se refaz sozinho (capas, vitrine, lista da biblioteca). Com a biblioteca no OneDrive, fica na pasta
+// local do Windows (%LOCALAPPDATA%\sagadeck\cache\<biblioteca>), fora da nuvem: não ocupa a cota, não sincroniza a
+// cada capa nova e uma máquina não pega o cache da outra. Fora do OneDrive (e no servidor): <biblioteca>/.cache.
+export function libraryCacheDir(root, { env = process.env, platform = process.platform } = {}) {
+  root = path.resolve(root);
+  const low = root.toLowerCase();
+  const clouds = platform === "win32" ? [env.OneDrive, env.OneDriveCommercial, env.OneDriveConsumer].filter(Boolean).map((p) => path.resolve(p).toLowerCase()) : [];
+  if (env.LOCALAPPDATA && clouds.some((c) => low === c || low.startsWith(c + path.sep))) {
+    const tag = `${safeName(path.basename(root), "biblioteca")}-${crypto.createHash("sha1").update(low).digest("hex").slice(0, 8)}`;
+    return path.join(env.LOCALAPPDATA, "sagadeck", "cache", tag);
+  }
+  return path.join(root, ".cache");
+}
+
 const isLink = (p) => { try { return fs.lstatSync(p).isSymbolicLink(); } catch { return false; } };
 const hasContent = (p) => { try { return fs.readdirSync(p).length > 0; } catch { return false; } };
 
@@ -150,6 +165,13 @@ export function openLibrary(root, { trashDays } = {}) {
   const keepDays = () => trashDays ?? loadPreferences().biblioteca?.lixeiraDias ?? TRASH_DAYS;
   root = path.resolve(root);
   fs.mkdirSync(root, { recursive: true });
+  const cacheDir = libraryCacheDir(root);
+  // o cache saiu da biblioteca no OneDrive (libraryCacheDir): o que ficou lá dentro é só do sagadeck e se refaz
+  if (cacheDir !== path.join(root, ".cache")) {
+    const old = path.join(root, ".cache");
+    for (const n of ["capas", "vitrine", "lista.json"]) try { fs.rmSync(path.join(old, n), { recursive: true, force: true }); } catch { /* travado pela sincronização: fica para a próxima */ }
+    try { fs.rmdirSync(old); } catch { /* não existe ou tem outra coisa */ }
+  }
 
   // caminho absoluto de um id, sem sair da biblioteca
   function resolveId(id) {
@@ -172,17 +194,48 @@ export function openLibrary(root, { trashDays } = {}) {
     return path.join(dir, same || files.sort()[0]);
   }
 
-  function deckInfo(file, topic) {
-    const st = fs.statSync(file);
+  // O que a listagem mostra de cada apresentação (título, slides, tema, avisos), guardado pela data, tamanho e inode
+  // do .yaml e do relatório de avisos: só relê o que mudou. Ler a data e o tamanho não abre o arquivo; ler o conteúdo,
+  // sim. Com a biblioteca no OneDrive e "arquivos só na nuvem", cada listagem baixava todas as apresentações, e
+  // interpretar o YAML de todas a cada abertura da biblioteca crescia com ela. Fica também em .cache/lista.json, para
+  // valer depois de reiniciar o Studio.
+  const listCacheFile = path.join(cacheDir, "lista.json");
+  let listCache = null, listCacheDirty = false;
+  const stamp = (f) => { const s = fs.statSync(f, { throwIfNoEntry: false }); return s ? `${s.mtimeMs}:${s.size}:${s.ino}` : "-"; };
+  function cachedInfo(file, own) {
+    if (!listCache) { try { listCache = JSON.parse(fs.readFileSync(listCacheFile, "utf8")) || {}; } catch { listCache = {}; } }
+    const id = idOf(file), key = `${stamp(file)}|${own ? stamp(path.join(path.dirname(file), ".sagadeck", "avaliacao-geracao.json")) : ""}`;
+    const hit = listCache[id];
+    if (hit?.key === key) return hit.info;
     let spec = {};
     try { spec = YAML.parse(fs.readFileSync(file, "utf8")) || {}; } catch {}
-    const own = idOf(file).split("/").length === 3;
     const pending = own ? pendingWarnings(path.dirname(file), spec) : 0;
+    const info = { title: String(spec.title || path.basename(file).replace(/\.ya?ml$/i, "")), slides: Array.isArray(spec.slides) ? spec.slides.length : 0, theme: spec.theme || "", ...(pending ? { pendencias: pending } : {}) };
+    listCache[id] = { key, info };
+    listCacheDirty = true;
+    return info;
+  }
+  function saveListCache(ids) {
+    if (!listCache) return;
+    for (const id of Object.keys(listCache)) if (!ids.has(id)) { delete listCache[id]; listCacheDirty = true; } // apagada ou movida
+    if (!listCacheDirty) return;
+    try {
+      fs.mkdirSync(path.dirname(listCacheFile), { recursive: true });
+      const tmp = `${listCacheFile}.tmp-${process.pid}`;
+      fs.writeFileSync(tmp, JSON.stringify(listCache));
+      renameRetry(tmp, listCacheFile);
+      listCacheDirty = false;
+    } catch { /* sem cache em disco: só fica a memória */ }
+  }
+
+  function deckInfo(file, topic) {
+    const st = fs.statSync(file);
+    const own = idOf(file).split("/").length === 3;
+    const { pendencias, ...info } = cachedInfo(file, own);
     return {
-      id: idOf(file), topic: topic || "", title: String(spec.title || path.basename(file).replace(/\.ya?ml$/i, "")),
-      slides: Array.isArray(spec.slides) ? spec.slides.length : 0, theme: spec.theme || "", edited: st.mtimeMs,
+      id: idOf(file), topic: topic || "", ...info, edited: st.mtimeMs,
       folder: own, // true = pasta própria (com imagens etc.); false = .yaml solto
-      ...(pending ? { pendencias: pending } : {}), // só quando há aviso
+      ...(pendencias ? { pendencias } : {}), // só quando há aviso
     };
   }
 
@@ -212,6 +265,7 @@ export function openLibrary(root, { trashDays } = {}) {
       topics.push({ id: e.name, name: e.name, color: meta.color || COLORS[topics.length % COLORS.length], count: mine.length, created: meta.created || 0 });
     }
     topics.sort((a, b) => a.name.localeCompare(b.name, "pt-BR"));
+    saveListCache(new Set(decks.map((d) => d.id)));
     return { root, topics, decks, trash: listTrash(), trashDays: keepDays() };
   }
 
@@ -560,7 +614,7 @@ export function openLibrary(root, { trashDays } = {}) {
   return {
     listStyles, saveStyle, loadStyle, applyStyleTo, defaultStyle, setDefaultStyle, withDefaultStyle,
     importOffice,
-    root, list, resolveId, idOf,
+    root, cacheDir, list, resolveId, idOf,
     createTopic, updateTopic, deleteTopic,
     createDeck, moveDeck, renameDeck, duplicateDeck, sendDeckTo,
     createStagingDeck, publishStagedDeck, discardStaging, recoverStaging,

package/src/studio/library-routes.js

@@ -54,7 +54,7 @@ export async function libraryRoutes({ req, res, pathname, url, W, opts, admin, u
     if (pathname === "/api/library/gallery-cover" && req.method === "GET") {
       const key = galleryKey(url.searchParams.get("key")), entry = galleryEntry(key);
       const spec = entry.dir ? { ...entry.spec, _dir: entry.dir } : entry.spec;
-      const cacheDir = path.join(L.root, ".cache", "vitrine");
+      const cacheDir = path.join(L.cacheDir, "vitrine");
       const cached = path.join(cacheDir, `${crypto.createHash("sha1").update(`${key}|${JSON.stringify(entry.spec)}`).digest("hex")}.jpg`);
       if (!fs.existsSync(cached)) {
         const [shot] = await slideSnapshots(spec, 0, { mode: "final", width: 480 });
@@ -68,7 +68,7 @@ export async function libraryRoutes({ req, res, pathname, url, W, opts, admin, u
     if (pathname === "/api/library/cover" && req.method === "GET") {
       const file = L.resolveId(url.searchParams.get("id"));
       const st = fs.statSync(file);
-      const cacheDir = path.join(L.root, ".cache", "capas");
+      const cacheDir = path.join(L.cacheDir, "capas");
       const cached = path.join(cacheDir, `${crypto.createHash("sha1").update(`${L.idOf(file)}|${st.mtimeMs}`).digest("hex")}.jpg`);
       if (!fs.existsSync(cached)) {
         const spec = loadSpec(file);

package/src/studio/shutdown.js

@@ -0,0 +1,31 @@
+// Parada do Studio quando o sistema pede (SIGTERM do systemd ao reiniciar, SIGHUP ao fechar o terminal). Sem isto,
+// o processo não saía: o Playwright, ao abrir o Chrome (miniaturas, fotos, exportação), instala um tratador de SIGTERM
+// que só fecha o navegador, e com um tratador instalado o Node deixa de sair sozinho. No servidor, cada reinício
+// ficava 90 s fora do ar até o systemd matar à força (SIGKILL), no meio do que estivesse rodando.
+// Aqui: para de aceitar conexões, dá `grace` ms para as que estão em uso terminarem (uma resposta da IA ao vivo, uma
+// gravação), corta o que sobrar, fecha o Chrome das miniaturas e sai.
+export const SINAIS_DE_PARADA = ["SIGTERM", "SIGHUP"];
+
+export function installShutdown(server, { grace = 8000, log = (m) => console.log(m), exit = (code) => process.exit(code), closeBrowsers } = {}) {
+  let stopping = null;
+  const stop = (signal) => {
+    if (stopping) return stopping;
+    stopping = (async () => {
+      log(`  ${signal}: parando o Studio (até ${Math.round(grace / 1000)} s para o que está em andamento)`);
+      const closed = new Promise((resolve) => server.close(() => resolve()));
+      // a conexão que termina a resposta fica aberta à espera de outra (keep-alive) e seguraria o close até o prazo
+      server.closeIdleConnections?.();
+      const idle = setInterval(() => server.closeIdleConnections?.(), 100);
+      let timer;
+      const late = new Promise((resolve) => { timer = setTimeout(() => { server.closeAllConnections?.(); resolve(); }, grace); });
+      await Promise.race([closed, late]);
+      clearTimeout(timer); clearInterval(idle);
+      try { await (closeBrowsers ?? (async () => (await import("./snapshot.js")).closeSnapshots()))(); } catch { /* o Chrome já fechou */ }
+      exit(0);
+    })();
+    return stopping;
+  };
+  const handlers = SINAIS_DE_PARADA.map((s) => [s, () => { stop(s); }]);
+  for (const [s, h] of handlers) process.on(s, h);
+  return { stop, uninstall: () => { for (const [s, h] of handlers) process.off(s, h); } };
+}