primocode 11.1.0 → 11.3.0

package/lib/motor/turno.js

@@ -0,0 +1,43 @@
+// Um turno sem tela: chama o runAct e emite o ciclo do turno.
+'use strict';
+
+const { EVENTOS, novoId } = require('./eventos');
+
+/* `iniciarTurno({ texto, ...opts, emitir })`. Sem `emitir`, usa a tela de terminal.
+   `opts` são os mesmos do runAct (server, model, token, history, projectDir…). */
+async function iniciarTurno({ texto, emitir, portao, ...opts }) {
+    const act = require('../session/runner/act');
+    const saida = emitir || require('./tela-terminal').criar();
+    const id = novoId();
+    const t0 = Date.now();
+    saida({ evento: EVENTOS.TURNO_COMECOU, id, tipo: 'turno', estado: 'rodando', texto });
+    let r;
+    try {
+        // Com `portao` (lib/motor/aprovacao.js), aprovações e perguntas viram eventos.
+        const viaPortao = portao ? { autorizar: portao.autorizar, mudarPasta: opts.mudarPasta || portao.mudarPasta } : {};
+        r = await act.runAct(texto, { ...opts, ...viaPortao, emitir: saida });
+    } catch (erro) {
+        if (portao) portao.cancelar();
+        saida({ evento: EVENTOS.TURNO_INTERROMPIDO, id, tipo: 'turno', estado: 'erro', duracao: Date.now() - t0, erro });
+        throw erro;
+    }
+    const duracao = Date.now() - t0;
+    if (portao) portao.cancelar();
+    // Contexto da conversa para a status line (régua do /compact, lib/memoria-conversa.js).
+    try {
+        const memoria = require('../session/memoria-conversa');
+        const hist = (opts.history || []).concat(r && r.userMessage ? [r.userMessage] : [], r && r.assistantMessage ? [r.assistantMessage] : []);
+        saida({ evento: EVENTOS.USO, id: novoId(), tipo: 'uso', estado: 'ok', contexto: memoria.usoDoContexto(memoria.nova(), hist) });
+    } catch { /* sem medida, a status line fica sem o número */ }
+    if (act.interrompido()) {
+        saida({ evento: EVENTOS.TURNO_INTERROMPIDO, id, tipo: 'turno', estado: 'interrompido', duracao, resultado: r });
+    } else {
+        saida({ evento: EVENTOS.TURNO_TERMINOU, id, tipo: 'turno', estado: 'ok', duracao, resultado: r });
+    }
+    return r;
+}
+
+const interromper = (...a) => require('../session/runner/act').interromper(...a);
+const mandarDuranteATarefa = (...a) => require('../session/runner/act').mandarDuranteATarefa(...a);
+
+module.exports = { iniciarTurno, interromper, mandarDuranteATarefa };

package/lib/motor/voz.js

@@ -0,0 +1,65 @@
+// Voz do app (docs/estrutura.md 6.9): interface com provedor trocável.
+// DECISÃO FINAL DO PROVEDOR PENDENTE com o dono. Aqui só o mínimo que não trava a escolha:
+//  - fala (TTS): provedor "kokoro" (voz local do Estúdio, grátis, gera arquivo de áudio; este módulo NUNCA toca som);
+//  - escuta (STT): fica no renderer (Web Speech API do navegador); o motor só informa que é do navegador.
+// Provedor = { nome, disponivel() -> {ok, motivo?}, falar(texto, arquivo) -> Promise<{ok, error?}> }.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TETO_TEXTO = 600;
+
+function provedorKokoro({ uv, voz, executar } = {}) {
+    const K = require('../plugin/estudio/kokoro');
+    const achar = () => uv || (() => { try { return require('child_process').execFileSync('which', ['uv'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; } catch { return null; } })();
+    return {
+        nome: 'kokoro',
+        disponivel() {
+            if (!achar()) return { ok: false, motivo: 'falta o uv (voz local)' };
+            if (!K.acharEspeak()) return { ok: false, motivo: 'falta o espeak-ng (brew install espeak-ng)' };
+            return { ok: true };
+        },
+        async falar(texto, arquivo) {
+            const r = await K.narrar([{ texto }], arquivo, { voz, uv: achar(), ...(executar ? { executar } : {}) });
+            return r && r.ok ? { ok: true } : { ok: false, error: (r && r.error) || 'a voz não respondeu' };
+        },
+    };
+}
+
+const PROVEDORES = { kokoro: (o) => provedorKokoro(o) };
+
+function criarVoz({ provedor, pasta, escuta = 'navegador' } = {}) {
+    const prov = provedor || PROVEDORES.kokoro();
+    const saida = pasta || path.join(os.tmpdir(), 'primocode-voz');
+    let ativa = false;
+    let n = 0;
+
+    const estado = () => {
+        const d = prov.disponivel();
+        return {
+            ativa, provedor: prov.nome, fala: { disponivel: !!d.ok, motivo: d.ok ? undefined : d.motivo },
+            escuta, decisaoPendente: true,
+        };
+    };
+
+    return {
+        estado,
+        /** Liga o modo voz; com `texto`, gera o arquivo de áudio da fala (não toca). */
+        async iniciar({ texto } = {}) {
+            ativa = true;
+            const e = estado();
+            const t = typeof texto === 'string' ? texto.trim().slice(0, TETO_TEXTO) : '';
+            if (!t) return e;
+            if (!e.fala.disponivel) return { ...e, fala: { ...e.fala, gerou: false } };
+            fs.mkdirSync(saida, { recursive: true });
+            const arquivo = path.join(saida, `fala-${Date.now()}-${++n}.mp3`);
+            const r = await prov.falar(t, arquivo);
+            return r.ok ? { ...e, arquivo } : { ...e, fala: { ...e.fala, gerou: false, motivo: r.error } };
+        },
+        parar() { ativa = false; return estado(); },
+    };
+}
+
+module.exports = { criarVoz, provedorKokoro, PROVEDORES, TETO_TEXTO };

package/lib/piloto.js

@@ -0,0 +1,39 @@
+// Piloto automático (docs/estrutura.md, seção 9): os agentes ligados procuram o que fazer e fazem.
+// Este módulo só decide QUEM roda e QUANDO parar; quem executa é injetado (o app-server passa o motor).
+// Node puro. Um ciclo roda os agentes ligados um de cada vez e para no freio da cota.
+'use strict';
+
+/* O que o agente recebe quando ninguém pediu nada: procurar trabalho no seu terreno. */
+function pedidoDoPiloto(agente, { grupo = false } = {}) {
+    return `[piloto automático] Você é @${agente.nome}. Procure UMA coisa útil para fazer no seu terreno `
+        + `(${agente.onde && agente.onde !== 'fora' ? `projeto ${agente.onde}` : 'fora de projetos'}) e faça. `
+        + 'Tudo que escrever arquivo vai para a pessoa aprovar antes de valer. Se não houver nada a fazer, diga isso em uma frase.'
+        + (grupo ? ' Se precisar de outro agente ligado, chame com spawn_agent (profundidade 1).' : '');
+}
+
+/* Freio padrão: a cota do plano (lib/limites.js). Sem rede vale o modo local generoso. */
+async function freioDaCota() {
+    try {
+        const c = await require('./config/limites').situacao();
+        if (c && (c.ok === false || c.liberado === false || c.restam === 0)) return { parar: true, motivo: 'a cota do plano acabou' };
+    } catch { /* sem leitura, não barra */ }
+    return { parar: false };
+}
+
+/* `ciclo({ agentes, executar, freio, ocupado, grupo })` → { executados:[{agente,ok,resumo}], parou? }.
+   `executar(agente, pedido)` devolve o resumo (texto) ou lança. */
+async function ciclo({ agentes = [], executar, freio = freioDaCota, ocupado = () => false, grupo = false } = {}) {
+    const ligados = agentes.filter((a) => a.ligado);
+    const r = { executados: [], parou: null };
+    if (!ligados.length) { r.parou = 'nenhum agente ligado'; return r; }
+    for (const a of ligados) {
+        if (ocupado()) { r.parou = 'a pessoa está trabalhando'; break; }
+        const f = await freio();
+        if (f && f.parar) { r.parou = f.motivo || 'freio'; break; }
+        try { r.executados.push({ agente: a.nome, ok: true, resumo: String(await executar(a, pedidoDoPiloto(a, { grupo })) || '').slice(0, 400) }); }
+        catch (e) { r.executados.push({ agente: a.nome, ok: false, resumo: (e && e.message) || 'falhou' }); }
+    }
+    return r;
+}
+
+module.exports = { ciclo, pedidoDoPiloto, freioDaCota };

package/lib/plugin/entregaveis/nucleo.js

@@ -103,7 +103,7 @@ function acharNavegador(env = process.env, existe = require('fs').existsSync) {
 function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
     if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
     const { spawnSync } = require('child_process');
-    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+    const r = spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--no-pdf-header-footer',
         `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
     return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
 }
@@ -180,7 +180,7 @@ function htmlParaPngs(htmlPath, baseSemExt, n, w, h, { escala = 1, navegador = a
         const tmp = `${baseSemExt}.tmp-${i}.html`;
         const alvo = `${baseSemExt}-${String(i).padStart(2, '0')}.png`;
         fs.writeFileSync(tmp, html.replace('</head>', `<style>section:not(:nth-of-type(${i})){display:none!important}html,body{height:${h}px;overflow:hidden}</style></head>`));
-        spawnSync(navegador, ['--headless=new', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
+        spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
             `--window-size=${w},${h}`, `--screenshot=${alvo}`, 'file://' + tmp], { encoding: 'utf8', timeout: 90000 });
         try { fs.unlinkSync(tmp); } catch {}
         if (fs.existsSync(alvo)) arquivos.push(alvo); else erro = `PNG ${i} não saiu`;

package/lib/plugin/estudio/criar.js

@@ -0,0 +1,113 @@
+// estudio_criar: a porta de entrada simples do Estúdio (docs/estrutura.md, seção 8).
+// Quatro parâmetros fixos (tipo, briefing, duracao, formato); por dentro escolhe a receita,
+// abre o projeto e chama as ferramentas que já existem (estudio_plano, estudio_motion,
+// estudio_render). Não reescreve nada do Estúdio. As dependências entram por parâmetro,
+// para o teste rodar sem rede e sem render.
+'use strict';
+
+const path = require('path');
+
+/* tipo → receita. `via`: 'roteiro' (plano pelo roteirista + render) ou 'motion' (a máquina de motion). */
+const TIPOS = Object.freeze({
+    slides:   { rotulo: 'Slides', via: 'roteiro', formato: '16:9', projeto: 'slides' },
+    video:    { rotulo: 'Vídeo curto', via: 'roteiro', formato: '9:16', projeto: 'video', duracao: [15, 60, 30] },
+    motion:   { rotulo: 'Motion', via: 'motion', formato: '9:16', duracao: [6, 60, 15] },
+    anuncio:  { rotulo: 'Anúncio', via: 'motion', formato: '9:16', duracao: [10, 30, 15], prefixo: 'Anúncio para chamar pra comprar: ' },
+    abertura: { rotulo: 'Abertura de canal', via: 'motion', formato: '16:9', duracao: [5, 5, 5], prefixo: 'Abertura de canal com a marca: ' },
+});
+const FORMATOS = ['9:16', '16:9', '1:1'];
+
+const limitar = (n, [min, max, padrao]) => { n = Number(n); return Number.isFinite(n) && n > 0 ? Math.min(max, Math.max(min, Math.round(n))) : padrao; };
+
+/** Confere os parâmetros. Devolve { ok, tipo, briefing, duracao, formato } ou { ok:false, error }. */
+function normalizar(args = {}) {
+    const tipo = String(args.tipo || '').toLowerCase().trim();
+    const receita = TIPOS[tipo];
+    if (!receita) return { ok: false, error: `tipo "${args.tipo || ''}" não existe. Use um de: ${Object.keys(TIPOS).join(', ')}.` };
+    const briefing = String(args.briefing || '').replace(/\s+/g, ' ').trim();
+    if (briefing.length < 3) return { ok: false, error: 'falta o briefing: diga em uma frase o que criar.' };
+    const formato = FORMATOS.includes(String(args.formato)) ? String(args.formato) : receita.formato;
+    const duracao = receita.duracao ? limitar(args.duracao, receita.duracao) : undefined;
+    return { ok: true, tipo, receita, briefing: briefing.slice(0, 600), formato, duracao };
+}
+
+/** Os arquivos entregues, com o tipo que a tela sabe abrir. */
+function arquivosDe(r) {
+    const lista = [];
+    const por = (caminho, extra) => { if (caminho) lista.push({ nome: path.basename(caminho), caminho, tipo: tipoDoArquivo(caminho), ...extra }); };
+    por(r.arquivo || r.video);
+    if (r.entrega && r.entrega.pasta && Array.isArray(r.entrega.arquivos)) {
+        for (const n of r.entrega.arquivos) { const c = path.join(r.entrega.pasta, n); if (!lista.some((x) => x.caminho === c)) por(c); }
+    }
+    return lista;
+}
+function tipoDoArquivo(c) {
+    const e = path.extname(c).toLowerCase();
+    if (e === '.mp4' || e === '.webm' || e === '.mov') return 'video';
+    if (e === '.pdf') return 'pdf';
+    if (['.png', '.jpg', '.jpeg', '.webp', '.gif'].includes(e)) return 'imagem';
+    if (e === '.html') return 'pagina';
+    return 'arquivo';
+}
+
+/**
+ * @param {object} args    { tipo, briefing, duracao?, formato? }
+ * @param {object} deps    { projeto, plano(args), motion(args), render(args), progresso(pct, etapa) }
+ */
+async function criar(args, deps) {
+    const n = normalizar(args);
+    if (!n.ok) return n;
+    const { tipo, receita, briefing, formato, duracao } = n;
+    const progresso = deps.progresso || (() => {});
+    const falha = (error, extra) => ({ ok: false, error, ...extra });
+
+    progresso(5, 'Abrindo o projeto');
+    const pedido = `${receita.prefixo || ''}${briefing}`;
+    const titulo = briefing.slice(0, 60);
+    const proj = deps.projeto.criar({ titulo, pedido: `${pedido} (${receita.rotulo}, ${formato}${duracao ? `, ${duracao} s` : ''})`, formato: receita.projeto || 'video' });
+    if (!proj || proj.ok === false) return falha((proj && proj.error) || 'não consegui abrir o projeto.');
+    const id = proj.id;
+    const base = { tipo, id, pasta: proj.pasta, formato, duracao, titulo };
+
+    if (receita.via === 'motion') {
+        progresso(15, 'Montando as cenas de motion');
+        const m = await deps.motion({ id, assunto: pedido, formato, duracao });
+        if (!m || m.ok === false) return falha((m && m.error) || 'o motion não saiu.', base);
+        progresso(100, 'Pronto');
+        return { ok: true, ...base, duracao: m.duracao || duracao, arquivo: m.video, arquivos: arquivosDe(m), resumo: `${receita.rotulo} de ${m.duracao || duracao} s.` };
+    }
+
+    progresso(15, 'Escrevendo o roteiro');
+    const pl = await deps.plano({ id, pedido: `${pedido}. Formato ${formato}.`, segundos: duracao });
+    if (!pl || pl.ok === false) return falha((pl && pl.error) || 'não consegui escrever o plano.', base);
+    progresso(40, tipo === 'slides' ? 'Desenhando os slides' : 'Montando o vídeo');
+    const r = await deps.render({ id });
+    if (!r || r.ok === false) return falha((r && r.error) || 'o render não saiu.', { ...base, problemas: r && r.problemas });
+    progresso(100, 'Pronto');
+    return {
+        ok: true, ...base, arquivo: r.arquivo, arquivos: arquivosDe(r), paginas: r.paginas,
+        duracao: r.segundos || duracao,
+        resumo: r.paginas ? `${r.paginas} slides em PDF.` : `${receita.rotulo} de ${r.segundos || duracao} s.`,
+    };
+}
+
+module.exports = { criar, normalizar, TIPOS, FORMATOS, tipoDoArquivo, arquivosDe };
+
+/* Os "quadrados" do Studio no app viram `tipo` no turn/start. O motor traduz o tipo em instrução:
+   o modelo escolhe o caminho (a IA decide); aqui só o cardápio do tipo. Carrossel não tem receita no Estúdio
+   (conferido na fase 7), por isso não há quadrado para ele. */
+const QUADRADOS = Object.freeze({
+    slides:  'Tipo escolhido na tela: Apresentação de slides. Use estudio_criar com tipo "slides" e o briefing do pedido (a skill slides-que-prendem ajuda no conteúdo).',
+    video:   'Tipo escolhido na tela: Vídeo curto vertical. Use estudio_criar com tipo "video" e o briefing do pedido.',
+    motion:  'Tipo escolhido na tela: Motion. Use estudio_criar com tipo "motion" e o briefing do pedido.',
+    anuncio: 'Tipo escolhido na tela: Anúncio de 15 s. Use estudio_criar com tipo "anuncio" e o briefing do pedido.',
+    abertura: 'Tipo escolhido na tela: Abertura de canal de 5 s. Use estudio_criar com tipo "abertura" e o briefing do pedido.',
+    pagina:  'Tipo escolhido na tela: Página ou app. Construa com write_file na pasta do projeto, confira abrindo no navegador e entregue o arquivo principal. Não use o Estúdio.',
+    bug:     'Tipo escolhido na tela: Corrigir um bug. Ache a causa lendo o código do projeto (read_file, grep), corrija com edit_file e crie um teste que pegue o caso; rode os testes e conte o que mudou. Não use o Estúdio.',
+    pr:      'Tipo escolhido na tela: Revisar um PR. Leia o diff do PR (o número ou o link que a pessoa der; gh ou git diff), aponte os riscos do mais grave ao menos grave e sugira a correção. Não use o Estúdio.',
+    app:     'Tipo escolhido na tela: Página ou app. Construa com write_file na pasta do projeto, confira abrindo no navegador e entregue o arquivo principal. Não use o Estúdio.',
+});
+const instrucaoDoTipo = (t) => QUADRADOS[String(t || '').toLowerCase()] || (t ? `Tipo de trabalho escolhido na tela: ${String(t).slice(0, 40)}` : '');
+
+module.exports.QUADRADOS = QUADRADOS;
+module.exports.instrucaoDoTipo = instrucaoDoTipo;

package/lib/plugin/estudio/gosto.js

@@ -519,6 +519,9 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0, inicio
         const token = crypto.randomBytes(16).toString('hex');
         let html;
         try { html = fs.readFileSync(path.join(__dirname, 'gosto', 'tela.html'), 'utf8'); } catch { return resolve({ ok: false, motivo: 'sem_tela' }); }
+        // No app do PrimoCode a tela abre num quadro (iframe) e o "Finalizar" (window.close) não faz nada ali: avisa a janela de fora
+        // para fechar o quadro. Entra na hora de servir, porque o gosto/tela.html é guardado sem mudança (test/kits-tela.test.js confere o sha1).
+        html = html.replace('</body>', "<script>document.addEventListener('click',function(e){var b=e.target.closest&&e.target.closest('#finalizar');if(b&&window.parent!==window)window.parent.postMessage('primocode:tela-fim','*');},true);</script></body>");
         // os vídeos que já estão no gosto: quem abre o /referencias de novo vê o que já trouxe (só o nome)
         const jaTem = ((ler(home) || {}).referencias || []).map((r) => String(r.nome || 'vídeo').slice(0, 80));
         const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO, INICIO: inicio === 'referencias' ? 'referencias' : 'carrossel', JA_TEM: jaTem }).replace(/</g, '\\u003c');

package/lib/plugin/estudio/historico.js

@@ -0,0 +1,60 @@
+// Histórico do Studio no app (studio/history): o que o Estúdio já gerou, com miniatura.
+// Lê as pastas de projeto (lib/estudio/projeto.js) sem mudar nada. Node puro.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { tipoDoArquivo } = require('./criar');
+const Miniatura = require('./miniatura');
+
+const PULAR = new Set(['node_modules', 'remotion', 'midia', 'entrada', 'versoes', '.git']);
+const SAIDAS = new Set(['video', 'pdf', 'imagem']);
+
+/* Procura as saídas em até 2 níveis; imagem solta (quadro de conferência) serve de miniatura, não de entrega. */
+function varrer(pasta, nivel = 0, achados = []) {
+    let itens = [];
+    try { itens = fs.readdirSync(pasta, { withFileTypes: true }); } catch { return achados; }
+    for (const d of itens) {
+        const c = path.join(pasta, d.name);
+        if (d.isDirectory()) { if (nivel < 2 && !PULAR.has(d.name) && !d.name.startsWith('.')) varrer(c, nivel + 1, achados); continue; }
+        const tipo = tipoDoArquivo(c);
+        if (!SAIDAS.has(tipo)) continue;
+        let st; try { st = fs.statSync(c); } catch { continue; }
+        achados.push({ nome: d.name, caminho: c, tipo, bytes: st.size, quando: st.mtimeMs, dentro: path.relative(pasta, c) });
+    }
+    return achados;
+}
+
+/** { itens, total }. `busca` filtra por título e pedido (sem acento); `limite` padrão 60. */
+function historico({ busca = '', limite = 60, projeto, miniaturaDeVideo } = {}) {
+    // Vídeo na grade vira um JPG (cache ao lado do vídeo). Até 4 saem na hora; o resto sai em segundo plano e aparece na próxima abertura.
+    const quadro = miniaturaDeVideo || Miniatura.gerar;
+    let gerados = 0;
+    const P = projeto || require('./projeto');
+    const sem = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+    const q = sem(busca).trim();
+    const itens = [];
+    for (const p of P.listar({ limite: 400 })) {
+        if (q && !sem(`${p.titulo} ${p.pedido}`).includes(q)) continue;
+        const todos = varrer(p.pasta).sort((a, b) => b.quando - a.quando);
+        const entregas = todos.filter((a) => a.tipo !== 'imagem' || /^saida\b/.test(a.dentro) || !todos.some((x) => x.tipo !== 'imagem'));
+        const principal = entregas.find((a) => a.tipo === 'video') || entregas.find((a) => a.tipo === 'pdf') || entregas[0] || null;
+        const imagem = todos.find((a) => a.tipo === 'imagem');
+        let miniatura = null;
+        if (principal && principal.tipo === 'imagem') miniatura = { tipo: 'imagem', caminho: principal.caminho };
+        else if (principal && principal.tipo === 'video') {
+            let jpg = Miniatura.emCache(principal.caminho);
+            if (!jpg && gerados < 4) { gerados++; jpg = quadro(principal.caminho); }
+            else if (!jpg && !miniaturaDeVideo) Miniatura.gerarDepois(principal.caminho);
+            miniatura = jpg ? { tipo: 'imagem', caminho: jpg, deVideo: true } : (imagem ? { tipo: 'imagem', caminho: imagem.caminho } : { tipo: 'video-sem-quadro', caminho: principal.caminho });
+        } else if (imagem) miniatura = { tipo: 'imagem', caminho: imagem.caminho };
+        itens.push({
+            id: p.id, titulo: p.titulo, formato: p.formato || 'video', criado: p.criado, mudado: p.mudado || p.criado,
+            pasta: p.pasta, arquivos: entregas.map(({ dentro, ...a }) => a), principal: principal ? principal.caminho : null, miniatura,
+            pronto: entregas.length > 0,
+        });
+    }
+    return { itens: itens.slice(0, Math.max(1, Number(limite) || 60)), total: itens.length };
+}
+
+module.exports = { historico, varrer };

package/lib/plugin/estudio/index.js

@@ -748,6 +748,19 @@ async function renderMotion(args, p, receita) {
     return { ...r, ...(gostoResumo ? { gosto: gostoResumo } : {}), nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' };
 }
 
+// ── estudio_criar ────────────────────────────────────────────────────────
+
+/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima. `ctx.progresso(pct, etapa)` alimenta o item da tela. */
+async function ferramentaCriar(args, ctx = {}) {
+    return require('./criar.js').criar(args, {
+        projeto,
+        plano: (a) => ferramentaPlano({ ...a, __pasta: ctx.projectDir }),
+        motion: (a) => ferramentaMotion(a),
+        render: (a) => ferramentaRender({ ...a, __pasta: ctx.projectDir }, ctx),
+        progresso: ctx.progresso,
+    });
+}
+
 // ── estudio_editar ───────────────────────────────────────────────────────
 
 /** O editor por comando: reabre o plano da máquina de motion, aplica as mudanças e guarda a versão (editor.js). */
@@ -2706,7 +2719,7 @@ async function ferramentaSite(args) {
 
 module.exports = { proporcaoDoPedido,
     vazamentoNoComeco, variarIcones, objetosDoRoteiro,
-    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar,
+    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar, ferramentaCriar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,
 };

package/lib/plugin/estudio/kits/tela.html

@@ -380,9 +380,11 @@ function mandar(rota, corpo) {
 }
 function erro(msg) { const e = $('#erro'); e.hidden = !msg; e.textContent = msg || ''; }
 
+/* No app do PrimoCode a tela abre dentro de um quadro (iframe): avisa a janela de fora que acabou, pra ela fechar o quadro. */
+function avisarApp() { try { if (window.parent !== window) setTimeout(() => window.parent.postMessage('primocode:tela-fim', '*'), 1200); } catch { /* aberta solta no navegador */ } }
 function mostrar(n) {
   [1, 4].forEach((i) => { $('#passo' + i).hidden = i !== n; });
-  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; }
+  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; avisarApp(); }
   window.scrollTo({ top: 0, behavior: parar ? 'auto' : 'smooth' });
 }
 

package/lib/plugin/estudio/miniatura.js

@@ -0,0 +1,56 @@
+// Miniatura de vídeo para a grade do Studio: um quadro em JPG, gerado pelo ffmpeg e guardado em cache ao lado
+// do vídeo (<pasta do vídeo>/.miniaturas/<nome>.jpg). A tela mostra <img>, nunca <video> na grade: vídeo em formato
+// que o Chromium não decodifica loga "Unsupported pixel format" só de abrir. Node puro, só `ffmpeg` do sistema.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+
+const PASTA = '.miniaturas';
+const LARGURA = 480;
+const emAndamento = new Set();
+
+const destinoDe = (video) => path.join(path.dirname(video), PASTA, `${path.basename(video)}.jpg`);
+const argsDe = (video, saida) => ['-v', 'error', '-ss', '0.5', '-i', video, '-frames:v', '1', '-vf', `scale=${LARGURA}:-2`, '-q:v', '4', '-y', saida];
+
+/* O cache vale enquanto o JPG existe, tem conteúdo e não é mais velho que o vídeo. */
+function emCache(video) {
+    const jpg = destinoDe(video);
+    try {
+        const j = fs.statSync(jpg); const v = fs.statSync(video);
+        return j.size > 0 && j.mtimeMs >= v.mtimeMs ? jpg : null;
+    } catch { return null; }
+}
+
+function ffmpegExiste(ffmpeg = 'ffmpeg') {
+    try { return spawnSync(ffmpeg, ['-version'], { stdio: 'ignore', timeout: 4000 }).status === 0; } catch { return false; }
+}
+
+/* Gera agora (bloqueia até uns segundos). Devolve o caminho do JPG, ou null se não deu. */
+function gerar(video, { ffmpeg = 'ffmpeg', espera = 8000 } = {}) {
+    const hit = emCache(video);
+    if (hit) return hit;
+    const jpg = destinoDe(video);
+    try { fs.mkdirSync(path.dirname(jpg), { recursive: true }); } catch { return null; }
+    try { spawnSync(ffmpeg, argsDe(video, jpg), { stdio: 'ignore', timeout: espera }); } catch { /* sem ffmpeg */ }
+    const ok = emCache(video);
+    if (!ok) { try { fs.rmSync(jpg, { force: true }); } catch { /* nada */ } }
+    return ok;
+}
+
+/* Gera sem bloquear (a próxima abertura do histórico já acha o JPG). Um por vídeo ao mesmo tempo. */
+function gerarDepois(video, { ffmpeg = 'ffmpeg' } = {}) {
+    if (emAndamento.has(video) || emCache(video)) return;
+    const jpg = destinoDe(video);
+    try { fs.mkdirSync(path.dirname(jpg), { recursive: true }); } catch { return; }
+    emAndamento.add(video);
+    let p;
+    try { p = spawn(ffmpeg, argsDe(video, jpg), { stdio: 'ignore' }); } catch { emAndamento.delete(video); return; }
+    const fim = () => { emAndamento.delete(video); if (!emCache(video)) { try { fs.rmSync(jpg, { force: true }); } catch { /* nada */ } } };
+    p.on('error', fim); p.on('close', fim);
+    const t = setTimeout(() => { try { p.kill('SIGKILL'); } catch { /* já saiu */ } }, 20000);
+    if (t.unref) t.unref();
+}
+
+module.exports = { gerar, gerarDepois, emCache, destinoDe, ffmpegExiste, PASTA };

package/lib/plugin/video/auto.js

@@ -301,7 +301,7 @@ const OPS = {
             const ver = plano.passos.map((p) => ({ op: p.op, motivo: p.motivo, args: p.args }));
             if (a.dryRun) return { ok: true, plano: ver, legenda: plano.legenda, segundos: 'da gravação' };
 
-            const { OPS: TODAS } = require('./ops.js');
+            const TODAS = require('./catalogo.js').catalogo();
             const feitos = [];
             const roda = async (op, args, motivo) => {
                 const res = await TODAS[op].run(ctx, args);

package/lib/plugin/video/catalogo.js

@@ -0,0 +1,20 @@
+/**
+ * catalogo.js — o catálogo completo das operações. ops.js registra aqui ao
+ * carregar; auto.js e pedido.js leem daqui para encadear operações sem
+ * importar ops.js (que os importa: isso fechava um ciclo).
+ */
+
+'use strict';
+
+let todas = null;
+
+function registrar(ops) {
+    todas = ops;
+}
+
+function catalogo() {
+    if (!todas) throw new Error('catálogo de operações vazio: carregue lib/video/ops.js antes');
+    return todas;
+}
+
+module.exports = { registrar, catalogo };

package/lib/plugin/video/mutar.js

@@ -0,0 +1,28 @@
+/**
+ * mutar.js — o caminho de toda operação que MUDA o projeto: foto de antes,
+ * edição, validação, gravação, delta. Se qualquer passo falha, nada é gravado.
+ *
+ * Mora fora de ops.js para os módulos de operação (ops-fx, zoom) usarem sem
+ * importar o catálogo que os importa.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+const { diff } = require('./delta.js');
+const P = require('./projeto.js');
+
+async function mutar(ctx, op, fn) {
+    const antes = T.clone(ctx.tl);
+    const extra = (await fn(ctx.tl)) || {};
+    T.ordenar(ctx.tl);
+    const probs = T.problemas(ctx.tl);
+    if (probs.length) throw T.erro(`edição recusada (nada mudou): ${probs.slice(0, 4).join('; ')}`);
+    P.fotografar(ctx.p, antes, op);
+    P.salvar(ctx.p, ctx.tl);
+    const d = diff(antes, ctx.tl, extra);
+    P.anotar(ctx.p, op, { dur: d.dur, added: (d.added || []).length, removed: (d.removed || []).length });
+    return d;
+}
+
+module.exports = { mutar };

package/lib/plugin/video/ops-fx.js

@@ -215,7 +215,7 @@ const OPS = {
                 ate = Math.min(asset.seconds, ate);
                 if (!(ate > de + 0.5)) throw T.erro('o momento 3D precisa de pelo menos meio segundo');
             }
-            return require('./ops.js').mutar(ctx, 'separate_layers', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'separate_layers', (tl) => {
                 const pessoa = camadaDaPessoa(tl, asset, rs);
                 const out = { layers: { pessoa: pessoa.length, fundo: 'a gravação embaixo' } };
                 if (a.show3d !== undefined) { C.limparPapel(tl, 'camadas3d', asset.id); C.limparGerados(tl); }
@@ -261,7 +261,7 @@ const OPS = {
             const seg = a.at === undefined ? await momento(ctx, asset, 'snap').catch(() => 0) : await momento(ctx, asset, a.at);
             const medido = await r().medirAsset(ctx.tl, arquivo);
             const ganho = ganhoDeCor(await corMedia(rs.arquivos.fundo), await corMedia(arquivo));
-            return require('./ops.js').mutar(ctx, 'replace_background', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'replace_background', (tl) => {
                 if (!temPessoa(tl, asset.id)) camadaDaPessoa(tl, asset, rs);
                 const F = quadro({ tl }, asset, seg) ?? 0;
                 const fim = a.until !== undefined ? Math.round(Number(a.until)) : T.duracao(tl);
@@ -334,7 +334,7 @@ const OPS = {
             if (de === null) de = t[0];
             const ate = a.to !== undefined ? await momento(ctx, asset, a.to) : Math.min(asset.seconds, Math.max(t[1] + 0.3, de + 1.5));
             if (!(ate > de)) throw T.erro('"to" antes de "from"');
-            return require('./ops.js').mutar(ctx, 'attach_3d', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'attach_3d', (tl) => {
                 const f = fxDe(tl, asset.id);
                 const o = { id: `o${f.objetos.length + 1}`, modelo, mao, de: r2(de * 1000) / 1000, ate: r2(ate * 1000) / 1000 };
                 if (a.color) o.cor = C.cor(a.color);
@@ -365,7 +365,7 @@ const OPS = {
             }
             const ateFusao = a.until !== undefined ? await momento(ctx, asset, a.until) : null;
             const depois = a.then === 'none' || a.then === false ? null : C.modeloDe(a.then || 'brain') || 'cerebro';
-            return require('./ops.js').mutar(ctx, 'merge_on_join', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'merge_on_join', (tl) => {
                 const f = fxDe(tl, asset.id);
                 // Os objetos vivos na junção ficam até ela (e se fundem).
                 for (const o of f.objetos) if (o.de < junta && o.ate < junta + 0.5) o.ate = r2((junta + 0.6) * 1000) / 1000;
@@ -400,7 +400,7 @@ const OPS = {
                 if (i1 > i0) ranges.push([T.origemParaQuadro(ctx.tl, c, i0), T.origemParaQuadro(ctx.tl, c, i1)]);
             }
             if (!ranges.length) return { ok: false, error: 'esse silêncio já foi cortado' };
-            return require('./ops.js').mutar(ctx, 'cut_silence_at', (tl) => ({ silence: { de: r2(de), ate: r2(ate) }, ...E.apagarTrechos(tl, ranges) }));
+            return require('./mutar.js').mutar(ctx, 'cut_silence_at', (tl) => ({ silence: { de: r2(de), ate: r2(ate) }, ...E.apagarTrechos(tl, ranges) }));
         },
     },
     style_captions: {
@@ -423,7 +423,7 @@ const OPS = {
             const CY = { bottom: 0.78, baixo: 0.78, top: 0.14, topo: 0.14, center: 0.5, centro: 0.5, middle: 0.5 };
             if (pos && !seguir && CY[pos] === undefined) throw T.erro(`position "${a.position}" (use above_head, bottom, top ou center)`);
             const corPedida = a.color !== undefined ? C.cor(a.color) : undefined;
-            return require('./ops.js').mutar(ctx, 'style_captions', (t) => {
+            return require('./mutar.js').mutar(ctx, 'style_captions', (t) => {
                 for (const ref of alvo) {
                     const c = T.achar(t, ref.id).clip;
                     const st = { ...(c.text.style || {}) };

package/lib/plugin/video/ops.js

@@ -17,6 +17,7 @@ const T = require('./timeline.js');
 const E = require('./edits.js');
 const F = require('./filters.js');
 const { diff } = require('./delta.js');
+const { mutar } = require('./mutar.js');
 const P = require('./projeto.js');
 const TR = require('./transcript.js');
 const A = require('./analise.js');
@@ -35,19 +36,6 @@ function alvos(tl, args, { tipos = ['video', 'image'] } = {}) {
     return refs.map((ref) => T.achar(tl, ref).clip.id);
 }
 
-async function mutar(ctx, op, fn) {
-    const antes = T.clone(ctx.tl);
-    const extra = (await fn(ctx.tl)) || {};
-    T.ordenar(ctx.tl);
-    const probs = T.problemas(ctx.tl);
-    if (probs.length) throw T.erro(`edição recusada (nada mudou): ${probs.slice(0, 4).join('; ')}`);
-    P.fotografar(ctx.p, antes, op);
-    P.salvar(ctx.p, ctx.tl);
-    const d = diff(antes, ctx.tl, extra);
-    P.anotar(ctx.p, op, { dur: d.dur, added: (d.added || []).length, removed: (d.removed || []).length });
-    return d;
-}
-
 function precisaProjeto(ctx) {
     if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."} (cria o projeto) ou new');
 }
@@ -311,6 +299,7 @@ const PED = require('./pedido.js');
 const AUTO = require('./auto.js');
 const ZOOM = require('./zoom.js');   // o zoom que segue o cursor (gravação de tela): fica na ajuda principal
 Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS, ZOOM.OPS);
+require('./catalogo.js').registrar(OPS);   // auto e pedido encadeiam operações por aqui
 
 const ALIAS = { timeline: 'get_timeline', transcript: 'get_transcript', captions: 'add_captions', texts: 'add_texts', render: 'export', pedido: 'do', analyze: 'track' };
 

package/lib/plugin/video/pedido.js

@@ -152,7 +152,7 @@ const OPS = {
             const resumo = plano.passos.map((p) => ({ op: p.op, args: p.args }));
             if (a.dryRun) return { ok: true, plano: resumo, ...(plano.avisos.length ? { avisos: plano.avisos } : {}) };
             if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
-            const { OPS: TODAS } = require('./ops.js');
+            const TODAS = require('./catalogo.js').catalogo();
             // O que é lento e não depende de nada roda JUNTO antes do primeiro passo.
             const C2 = require('./camadas.js');
             const asset = C2.base(tl);

package/lib/plugin/video/zoom.js

@@ -231,7 +231,7 @@ const OPS = {
         async run(ctx, a) {
             const T = require('./timeline.js');
             const E = require('./edits.js');
-            const { mutar } = require('./ops.js');
+            const { mutar } = require('./mutar.js');
             if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."}');
             const primeiro = T.todosOsClipes(ctx.tl).find((x) => x.clip.type === 'video');
             if (!a.id && !primeiro) throw T.erro('não há clipe de vídeo');