primocode 8.18.1 → 8.20.0

package/bin/primocode.js

@@ -522,8 +522,11 @@ const RE_DESCOBRIR = /\b(pesquis|busca|procur|descubr|investig|analis|leia|estud
 const RE_CRIAR_DEPOIS = /\b(cri[ae]|faz|faça|mont[ae]|ger[ae]|escrev[ae]|produz|desenvolv)\w*/i;
 
 /** "baixa/exporta o vídeo" resolvido na hora, sem gastar modelo. */
-const RE_BAIXAR = /\b(baixa\w*|exporta\w*|download|salva\w*)\b/i;
-const RE_PECA_STUDIO = /\b(v[ií]deo|mp4|mp3|apresenta[çc][ãa]o|slides?|reels?)\b/i;
+// "me manda o vídeo", "quero pra mandar no zap", "gera o arquivo" — a lista
+// era curta e o pedido sai de muitos jeitos. Fora dela, o pedido virava
+// tarefa de agente: gasto de API para abrir uma URL que o CLI já sabe.
+const RE_BAIXAR = /\b(baixa\w*|exporta\w*|download|salva\w*|grava\w*|me manda|manda(r)? (o|a|esse|essa)|gera(r)? o arquivo|em mp4|pra mandar|arquivo do)\b/i;
+const RE_PECA_STUDIO = /\b(v[ií]deo|mp4|mp3|apresenta[çc][ãa]o|slides?|reels?|anima[çc][ãa]o|filme)\b/i;
 
 async function baixarCriacaoDireto(texto) {
     if (!(RE_BAIXAR.test(texto) && RE_PECA_STUDIO.test(texto))) return false;

package/lib/act.js

@@ -529,6 +529,26 @@ async function runAct(userPrompt, opts) {
 
         let finished = null;
         let algoRodou = false;
+
+        // ORQUESTRAÇÃO: subagentes da MESMA rodada rodam juntos. O modelo que
+        // pede "3 agentes, um por arquivo" esperava paralelismo e recebia uma
+        // fila — cada subagente só começava quando o anterior terminava, e a
+        // rodada custava a soma dos três. Agora as chamadas spawn_agent da
+        // rodada disparam de uma vez (Promise.all) e cada resultado volta na
+        // posição certa da conversa. Limite de 4 por rodada: acima disso é
+        // sinal de decomposição ruim, e o excedente roda em série mesmo.
+        const spawns = toolCalls.filter((tc) => tc.name === 'spawn_agent');
+        const resultadosSpawn = new Map();
+        if (spawns.length > 1 && !PARAR) {
+            const juntos = spawns.slice(0, 4);
+            console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agentes'))} ${c.muted(`${juntos.length} em paralelo`)}`);
+            const rs = await Promise.all(juntos.map((tc) =>
+                runSubagent(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                }).catch((e) => `Subagente falhou: ${e && e.message}`)));
+            juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
+        }
+
         for (const tc of toolCalls) {
             if (PARAR) break;
             if (tc.name === 'finish') {
@@ -552,9 +572,11 @@ async function runAct(userPrompt, opts) {
 
             if (tc.name === 'spawn_agent') {
                 algoRodou = true;
-                const r = await runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
-                });
+                const r = resultadosSpawn.has(tc.id)
+                    ? resultadosSpawn.get(tc.id)
+                    : await runSubagent(tc.arguments || {}, {
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.18.1",
+  "version": "8.20.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/studio/ferramentas/corte.md

@@ -1,7 +1,7 @@
 # CORTE — vídeo
 
 No lugar de CapCut, Premiere e After Effects. Modelo `cena`, com `duracao` em cada
-cena, trilha sonora, transições e gravação em `.webm`.
+cena, trilha sonora, transições e download em `.mp4`.
 
 <!-- O EXEMPLO FICA NO COMEÇO DE PROPÓSITO: quando o plano de tokens é
 apertado, o agente recebe só os primeiros ~3500 caracteres desta spec. Um
@@ -174,6 +174,33 @@ Regras que fazem diferença:
 O usuário também pode gravar a própria voz pelo editor; aí a cena ganha
 `narracaoAudio` com o arquivo, e ela tem prioridade sobre a voz sintetizada.
 
+**Sincronia é automática.** Quando o estúdio gera a narração em arquivo, ele
+mede o áudio e grava `narracaoDur` na cena; a cena então dura o que for maior —
+a `duracao` pedida ou a fala inteira mais um respiro. Não calcule isso à mão,
+e não apague `narracaoDur` ao ajustar um documento.
+
+**Mixagem é automática.** A música abaixa sozinha enquanto a voz fala (ducking)
+e volta no intervalo entre as falas. Não compense baixando o `volume` da trilha:
+deixe em 0.6–0.8 e o duck cuida do resto.
+
+---
+
+## Efeitos sonoros
+
+Cada troca de cena ganha um efeito sintetizado na hora, sem arquivo e sem
+licença: transição `flash` e `zoom` soam um **impacto** grave; as demais, um
+**whoosh** (variado, para não repetir); `corte` fica em silêncio.
+
+Para controlar:
+
+```json
+"sfx": false                  // no documento: desliga todos os efeitos
+{ "transicao": "deslizar", "sfx": "impacto" }   // na cena: força um efeito
+```
+
+Valores por cena: `"whoosh"` · `"impacto"` · `"click"` · `"nenhum"`.
+O padrão (sem declarar nada) já é o certo para a maioria dos vídeos.
+
 ---
 
 ## Transições
@@ -269,11 +296,25 @@ play/pausa, linha do tempo clicável com marca por cena, tempo, volume e **Grava
 
 `K` toca e pausa · `M` corta o som · `→` `←` pulam cena · `F` tela cheia · `Escape` para.
 
-## Virar arquivo de vídeo
+## Baixar o vídeo como arquivo
+
+O botão **Baixar MP4** no player faz tudo sozinho: pede a permissão de captura, toca
+do começo, para no fim e baixa. Sai `.mp4` (H.264/AAC, que toca em qualquer lugar) nos
+navegadores que sabem gravar MP4; onde não sabem, sai `.webm`.
+
+**Se o usuário pedir o arquivo do vídeo** — "baixa", "exporta", "me manda em mp4",
+"quero mandar no WhatsApp" — abra o player já em modo de gravação:
+
+```
+open_in_browser  →  http://localhost:7777/v/<id>#gravar
+```
+
+A âncora `#gravar` dispara o download assim que a página abre; o usuário só confirma a
+permissão de captura. **Não** use `write_file` para criar `.mp4`, e **nunca** chame
+ffmpeg: o vídeo já nasce pronto aqui, e escrever um `.mp4` com write_file produz um
+arquivo de texto com nome de vídeo — já aconteceu.
 
-O botão **Gravar** usa a captura de tela do navegador: escolha a aba, o vídeo toca do
-começo, para sozinho no fim e baixa um `.webm` com a trilha junto. Para o melhor
-resultado, entre em tela cheia (`F`) antes de gravar.
+Para o melhor resultado, entre em tela cheia (`F`) antes de gravar.
 
 O export normal (`/api/arquivos/<id>/export`) devolve um `.html` autônomo com a
 mídia embutida — abre offline em qualquer navegador e toca igual.

package/studio/server.py

@@ -20,6 +20,7 @@ import threading
 import time
 import unicodedata
 import uuid
+import wave
 from datetime import datetime, timezone
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import urlparse, unquote, urlencode
@@ -184,11 +185,30 @@ def ler(arq_id):
 
 def gravar(arq):
     arq["atualizado"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
-    with open(caminho(arq["id"]), "w", encoding="utf-8") as fh:
+    destino = caminho(arq["id"])
+    # Escrita atômica: o servidor é multi-thread (autosave do editor a cada
+    # 600 ms + a thread de narração gravando o mesmo doc). Escrever direto
+    # podia deixar um JSON pela metade se duas gravações se cruzassem ou o
+    # processo caísse no meio. Com tmp + replace, ou o arquivo antigo está
+    # inteiro, ou o novo está inteiro — nunca metade.
+    tmp = destino + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as fh:
         json.dump(arq, fh, ensure_ascii=False, indent=2)
+    os.replace(tmp, destino)
     return arq
 
 
+def _duracao_wav(dados):
+    """Segundos de um WAV em bytes; None se não der para medir."""
+    try:
+        import io
+        with wave.open(io.BytesIO(dados), "rb") as w:
+            fr = w.getframerate()
+            return (w.getnframes() / fr) if fr else None
+    except Exception:
+        return None
+
+
 # ------------------------------------------------------------------ versões --
 #
 # Um pedido de ajuste apagou o trabalho de um usuário: ele tinha um vídeo de
@@ -335,6 +355,11 @@ def _gravar_narracao(arq_id):
         for _ in range(120):
             if voz_lib.pronta():
                 break
+            # Máquina onde o Piper nunca vai rodar (binário de outra
+            # arquitetura): esperar 10 minutos aqui era esperar por nada.
+            if voz_lib.bloqueado():
+                sys.stderr.write("[voz] motor neural bloqueado: %s\n" % voz_lib.bloqueado())
+                return
             voz_lib.instalar()
             time.sleep(5)
         if not voz_lib.pronta():
@@ -376,6 +401,14 @@ def _gravar_narracao(arq_id):
                 fh.write(audio)
             c["narracaoAudio"] = "/midia/" + nome
             c["narracaoVoz"] = assinatura
+            # A duração medida do WAV vai junto: com ela o player sabe quanto
+            # a cena REALMENTE dura (a fala inteira + respiro) e a linha do
+            # tempo vira determinística — sem ela, o relógio congela na
+            # beirada da cena esperando a voz, e a duração do vídeo muda a
+            # cada reprodução.
+            dur = _duracao_wav(audio)
+            if dur:
+                c["narracaoDur"] = round(dur, 2)
             mudou = True
 
         if mudou:
@@ -389,6 +422,8 @@ def _gravar_narracao(arq_id):
                             and cenas[i].get("narracao") == c.get("narracao"):
                         cenas[i]["narracaoAudio"] = c["narracaoAudio"]
                         cenas[i]["narracaoVoz"] = c["narracaoVoz"]
+                        if c.get("narracaoDur"):
+                            cenas[i]["narracaoDur"] = c["narracaoDur"]
                 gravar(atual)
     except Exception as e:
         sys.stderr.write("[voz] narração em arquivo falhou: %s\n" % e)
@@ -1577,7 +1612,7 @@ def html_autonomo(a):
             return fh.read()
 
     js = "\n".join(leia("js", n) for n in
-                   ("icones.js", "audio.js", "render.js", "render-prosa.js", "render-grade.js"))
+                   ("icones.js", "audio.js", "sfx.js", "render.js", "render-prosa.js", "render-grade.js"))
 
     dados = json.dumps(a, ensure_ascii=False).replace("</script", "<\\/script")
 
@@ -1603,7 +1638,50 @@ def html_autonomo(a):
 
 # -------------------------------------------------------------------- main --
 
+def _abrir_log():
+    """Diagnóstico que sobrevive ao `stdio: 'ignore'` do CLI.
+
+    O CLI sobe este servidor descartando stdout/stderr — e era exatamente
+    para lá que iam os erros de voz e o traceback de porta ocupada. Ninguém
+    via nada: o Studio "não subia" em silêncio. Espelhar stdout/stderr num
+    arquivo ao lado do código dá onde olhar. Rotação simples: passou de
+    2 MB, o log atual vira `.old` e começa outro.
+    """
+    try:
+        destino = os.path.join(RAIZ, "studio.log")
+        if os.path.exists(destino) and os.path.getsize(destino) > 2 * 1024 * 1024:
+            os.replace(destino, destino + ".old")
+        fh = open(destino, "a", encoding="utf-8", buffering=1)
+
+        class _Tee:
+            def __init__(self, original):
+                self.original = original
+            def write(self, s):
+                try:
+                    self.original.write(s)
+                except Exception:
+                    pass
+                try:
+                    fh.write(s)
+                except Exception:
+                    pass
+            def flush(self):
+                for alvo in (self.original, fh):
+                    try:
+                        alvo.flush()
+                    except Exception:
+                        pass
+
+        sys.stdout = _Tee(sys.stdout)
+        sys.stderr = _Tee(sys.stderr)
+        print("[studio] %s — iniciando na porta %d" %
+              (datetime.now(timezone.utc).isoformat(timespec="seconds"), PORTA))
+    except Exception:
+        pass          # sem log ainda é melhor que sem servidor
+
+
 if __name__ == "__main__":
+    _abrir_log()
     url = "http://localhost:%d" % PORTA
     print("""
   ██  PrimoCode Studio
@@ -1619,3 +1697,12 @@ if __name__ == "__main__":
         ThreadingHTTPServer(("127.0.0.1", PORTA), Handler).serve_forever()
     except KeyboardInterrupt:
         print("\n  Encerrado.\n")
+    except OSError as e:
+        # Porta ocupada saía como traceback — e com stdio descartado pelo
+        # CLI, saía para lugar nenhum. Mensagem clara + código de saída
+        # próprio: quem supervisiona sabe o que houve sem ler stack.
+        if getattr(e, "errno", None) in (48, 98, 10048):   # mac, linux, windows
+            print("\n  A porta %d já está em uso — outro Studio no ar?\n"
+                  "  Feche-o (POST /api/sair) ou use PRIMOCODE_STUDIO_PORT.\n" % PORTA)
+            sys.exit(2)
+        raise

package/studio/voz.py

@@ -117,8 +117,66 @@ def instaladas():
     return [v["id"] for v in CATALOGO if modelo(v["id"])]
 
 
+# O binário EXISTIR não prova que ele RODA. O pacote macos_aarch64 do Piper
+# 2023.11.14-2 veio com executável x86_64 dentro — num Mac Apple Silicon sem
+# Rosetta, spawná-lo morre com "Bad CPU type" (errno 86). Sem esta checagem,
+# `pronta()` dizia sim, o servidor esperava a voz que nunca viria, e cada
+# pedido de narração travava a corrente inteira de motores por minutos.
+# A prova roda UMA vez e o veredito fica em arquivo: reiniciar não re-testa,
+# e reinstalar (apagar()) limpa o veredito junto.
+_MARCA_INCOMPATIVEL = os.path.join(CASA, "binario-incompativel")
+_roda_cache = None
+
+
+def marcar_incompativel(motivo):
+    global _roda_cache
+    _roda_cache = False
+    try:
+        os.makedirs(CASA, exist_ok=True)
+        with open(_MARCA_INCOMPATIVEL, "w") as fh:
+            fh.write(str(motivo))
+    except Exception:
+        pass
+
+
+def bloqueado():
+    """Por que o Piper nunca vai funcionar nesta máquina — ou None."""
+    try:
+        if os.path.exists(_MARCA_INCOMPATIVEL):
+            with open(_MARCA_INCOMPATIVEL) as fh:
+                return fh.read().strip() or "binário incompatível com esta máquina"
+    except Exception:
+        pass
+    return None
+
+
+def _binario_roda():
+    global _roda_cache
+    if _roda_cache is not None:
+        return _roda_cache
+    if bloqueado():
+        _roda_cache = False
+        return False
+    exe = binario()
+    if not exe:
+        return None                     # ainda não baixou: sem veredito
+    try:
+        subprocess.run([exe, "--version"], stdout=subprocess.DEVNULL,
+                       stderr=subprocess.DEVNULL, timeout=10)
+        _roda_cache = True
+    except OSError as e:
+        if getattr(e, "errno", None) == 86:      # Bad CPU type (macOS)
+            marcar_incompativel("o pacote do Piper veio com binário de outra "
+                                "arquitetura (x86_64 num Mac ARM sem Rosetta)")
+        else:
+            marcar_incompativel("o binário do Piper não executa: %s" % e)
+    except Exception:
+        _roda_cache = True              # demorou mas executa: não é errno 86
+    return _roda_cache
+
+
 def pronta(voz_id=None):
-    return bool(binario() and modelo(voz_id or PADRAO))
+    return bool(binario() and modelo(voz_id or PADRAO) and _binario_roda())
 
 
 # ------------------------------------------------------------------ baixar --
@@ -209,6 +267,11 @@ def instalar(voz_id=None, esperar=0):
     que faz ela estar pronta na hora de tocar."""
     global _thread
     voz_id = voz_id if voz_id in POR_ID else PADRAO
+    # Baixar de novo não conserta binário de arquitetura errada: viria o
+    # mesmo pacote. Sem esta guarda, cada pedido de narração re-disparava
+    # os ~90 MB de download para nada.
+    if bloqueado():
+        return estado()
     with _tranca:
         if _thread is None and not pronta(voz_id):
             _baixando.update(ativo=True, voz=voz_id, pct=0, etapa="começando", erro=None)
@@ -227,7 +290,11 @@ def estado():
         "motor": "piper",
         "pronta": pronta(),
         "instaladas": instaladas(),
-        "suportado": bool(_versao_pacote()),
+        # "suportado" responde à pergunta de verdade: o Piper VAI funcionar
+        # aqui? Pacote inexistente para a plataforma e binário que não roda
+        # são o mesmo "não" — e `bloqueado` explica o porquê.
+        "suportado": bool(_versao_pacote()) and not bloqueado(),
+        "bloqueado": bloqueado(),
         "baixando": b,
         "vozes": [{
             "id": v["id"], "nome": v["nome"], "tom": v["tom"], "hz": v["hz"], "mb": v["mb"],
@@ -265,7 +332,7 @@ def sintetizar(texto, voz_id=None, grave=False, velocidade=1.0, timeout=120):
     exe = binario()
     voz_id = voz_id if voz_id in POR_ID else PADRAO
     mod = modelo(voz_id)
-    if not exe or not mod:
+    if not exe or not mod or not _binario_roda():
         return None
 
     # Sem isto, um texto com quebra de linha vira várias falas e o Piper
@@ -282,13 +349,22 @@ def sintetizar(texto, voz_id=None, grave=False, velocidade=1.0, timeout=120):
     pasta = tempfile.mkdtemp(prefix="primo-voz-")
     try:
         saida = os.path.join(pasta, "voz.wav")
-        r = subprocess.run(
-            [exe, "--model", mod + ".onnx", "--config", mod + ".onnx.json",
-             "--length_scale", "%.3f" % escala, "--sentence_silence", "0.25",
-             "--output_file", saida],
-            input=limpo.encode("utf-8"),
-            stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=timeout,
-        )
+        try:
+            r = subprocess.run(
+                [exe, "--model", mod + ".onnx", "--config", mod + ".onnx.json",
+                 "--length_scale", "%.3f" % escala, "--sentence_silence", "0.25",
+                 "--output_file", saida],
+                input=limpo.encode("utf-8"),
+                stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=timeout,
+            )
+        except OSError as e:
+            # errno 86 = binário de outra arquitetura (macOS). Marca de vez:
+            # a corrente cai para o próximo motor e ninguém trava de novo.
+            if getattr(e, "errno", None) == 86:
+                marcar_incompativel("o pacote do Piper veio com binário de "
+                                    "outra arquitetura (x86_64 num Mac ARM sem Rosetta)")
+                return None
+            raise
         if r.returncode != 0 or not os.path.exists(saida):
             raise RuntimeError((r.stderr or b"").decode("utf-8", "replace")[-300:] or "piper falhou")
         if grave:
@@ -301,7 +377,12 @@ def sintetizar(texto, voz_id=None, grave=False, velocidade=1.0, timeout=120):
 
 def apagar():
     """Some com tudo que foi baixado. Existe para o usuário poder desfazer:
-    são 90 MB na máquina dele, e ele tem direito de recuperá-los."""
+    são 90 MB na máquina dele, e ele tem direito de recuperá-los.
+    O veredito de incompatibilidade vai junto (mora dentro de CASA): quem
+    instalar de novo — num Mac com Rosetta, num pacote corrigido — merece
+    uma prova nova, não a sentença antiga."""
+    global _roda_cache
+    _roda_cache = None
     if os.path.isdir(CASA):
         shutil.rmtree(CASA, ignore_errors=True)
     return {"ok": True}

package/studio/web/js/audio.js

@@ -65,7 +65,8 @@ function criarTrilha(cfg, aoErro) {
 
   var ctx = new Ctx();
   var mestre = ctx.createGain();
-  mestre.gain.value = cfg.volume != null ? cfg.volume : 0.7;
+  var volumeBase = cfg.volume != null ? cfg.volume : 0.7;
+  mestre.gain.value = volumeBase;
 
   var compressor = ctx.createDynamicsCompressor();
   compressor.threshold.value = -14;
@@ -77,17 +78,49 @@ function criarTrilha(cfg, aoErro) {
   var paraGravar = ctx.createMediaStreamDestination();
   compressor.connect(paraGravar);
 
+  /* Entrada da NARRAÇÃO: depois do `mestre`, antes do compressor. A voz não
+     passa pelo volume da trilha nem pelo duck — quem abaixa é a música, nunca
+     a fala. E como desemboca no mesmo compressor, a voz entra na gravação
+     MP4 pelo grafo, sem depender de "compartilhar áudio da aba". */
+  var entradaVoz = ctx.createGain();
+  entradaVoz.gain.value = 1;
+  entradaVoz.connect(compressor);
+
   var api = {
     ctx: ctx,
+    no: compressor,                 // onde SFX e outras fontes se conectam
+    entradaVoz: entradaVoz,
     fluxo: paraGravar.stream,
     tocando: false,
     tocar: function () {},
     parar: function () {},
-    volume: function (v) { mestre.gain.value = v; },
+    volume: function (v) { volumeBase = v; mestre.gain.value = v; },
     esmaecer: function () {},
     duracao: function () { return null; },
+    /* Ducking: a trilha cede espaço enquanto a narração fala.
+       Rampa curta para descer (a voz não espera) e longa para voltar. */
+    duck: function (ligado) {
+      var agora = ctx.currentTime;
+      mestre.gain.cancelScheduledValues(agora);
+      mestre.gain.setValueAtTime(mestre.gain.value, agora);
+      mestre.gain.linearRampToValueAtTime(
+        ligado ? volumeBase * 0.35 : volumeBase,
+        agora + (ligado ? 0.15 : 0.5));
+    },
   };
 
+  /* -------------------------------------------------------- sem trilha ---- */
+  /* tipo "nenhuma": o documento não tem música, mas o grafo ainda serve —
+     é por ele que narração e SFX entram na gravação. */
+  if (cfg.tipo === "nenhuma") {
+    api.tocar = function () {
+      if (ctx.state === "suspended") ctx.resume();
+      api.tocando = true;
+    };
+    api.parar = function () { api.tocando = false; };
+    return api;
+  }
+
   /* --------------------------------------------------------- arquivo ---- */
 
   if (cfg.tipo !== "gerada" && cfg.src) {