primocode 8.11.1 → 8.12.0

package/studio/server.py

@@ -25,6 +25,37 @@ from urllib.parse import urlparse, unquote, urlencode
 import urllib.request
 
 RAIZ = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, RAIZ)
+try:
+    import voz as voz_lib  # noqa: E402  (precisa da RAIZ no path antes)
+except Exception as _e:    # instalação parcial, ou voz.py de uma versão velha
+    # Narração é acabamento; o Studio inteiro não pode morrer por causa dela.
+    # Sem o módulo, a corrente começa direto no Google e tudo mais funciona.
+    sys.stderr.write("[voz] módulo indisponível (%s); narração vai só pelo Google\n" % _e)
+
+    class _SemVoz:
+        @staticmethod
+        def pronta(*a, **k):
+            return False
+
+        @staticmethod
+        def sintetizar(*a, **k):
+            return None
+
+        @staticmethod
+        def instalar(*a, **k):
+            return {"pronta": False, "erro": "módulo de voz indisponível"}
+
+        @staticmethod
+        def estado():
+            return {"pronta": False, "vozes": [], "erro": "módulo de voz indisponível"}
+
+        @staticmethod
+        def apagar():
+            return {"ok": True}
+
+    voz_lib = _SemVoz()
+
 WEB = os.path.join(RAIZ, "web")
 ARQUIVOS = os.path.join(RAIZ, "arquivos")
 FERRAMENTAS = os.path.join(RAIZ, "ferramentas")
@@ -32,13 +63,21 @@ MIDIA = os.path.join(RAIZ, "midia")
 PORTA = int(sys.argv[1]) if len(sys.argv) > 1 else 7777
 
 def _assinatura():
-    """SHA-1 do próprio arquivo, lido NA SUBIDA. Se o npm trocar o código no
+    """SHA-1 do código do Studio, lido NA SUBIDA. Se o npm trocar o código no
     disco depois, o processo no ar continua respondendo a assinatura antiga —
     e é exatamente essa diferença que o CLI usa para saber que precisa
-    reiniciar o Studio em vez de servir a versão velha para sempre."""
+    reiniciar o Studio em vez de servir a versão velha para sempre.
+
+    Entra todo módulo do Studio, não só este arquivo: uma correção que mexa
+    apenas na voz também precisa derrubar o processo velho."""
+    h = hashlib.sha1()
     try:
-        with open(os.path.abspath(__file__), "rb") as fh:
-            return hashlib.sha1(fh.read()).hexdigest()[:12]
+        for nome in ("server.py", "voz.py"):
+            caminho = os.path.join(RAIZ, nome)
+            if os.path.exists(caminho):
+                with open(caminho, "rb") as fh:
+                    h.update(fh.read())
+        return h.hexdigest()[:12]
     except Exception:
         return "?"
 
@@ -149,6 +188,132 @@ def gravar(arq):
     return arq
 
 
+# ------------------------------------------------------------------ versões --
+#
+# Um pedido de ajuste apagou o trabalho de um usuário: ele tinha um vídeo de
+# oito cenas, com narração e trilha, pediu "aplique a identidade visual" e o
+# agente mandou um PUT com doc={"tema":"..."}. O handler trocava o documento
+# INTEIRO pelo que chegou — as oito cenas, a narração e a trilha viraram um
+# documento de uma chave só. Não havia como voltar.
+#
+# Daí saíram duas defesas. `mesclar` faz o pedido parcial ser parcial de
+# verdade, que é o conserto. Este histórico é o que sobra quando o conserto
+# não basta: guarda o estado anterior a cada gravação, para que sobrescrever
+# nunca mais seja definitivo. Nada aqui apaga o arquivo vivo; o pior caso é
+# ocupar disco, e vinte versões de um documento de texto não dão um megabyte.
+
+VERSOES = os.path.join(ARQUIVOS, ".versoes")
+MAX_VERSOES = 20
+
+
+_seq_versao = 0
+
+
+def guardar_versao(arq):
+    """Copia o estado atual para .versoes/<id>/<carimbo>.json antes de trocar.
+
+    O carimbo é ordenável como texto, e por isso precisa de milissegundo: o
+    editor do navegador salva a cada 600 ms, e duas versões do mesmo segundo
+    desempatadas por sorteio fariam "desfaz a última mudança" desfazer a
+    penúltima. O contador no fim resolve o empate que sobra."""
+    global _seq_versao
+    try:
+        pasta = os.path.join(VERSOES, arq["id"])
+        os.makedirs(pasta, exist_ok=True)
+        _seq_versao = (_seq_versao + 1) % 10000
+        agora = datetime.now(timezone.utc)
+        carimbo = "%s%03d-%04d" % (agora.strftime("%Y%m%dT%H%M%S"),
+                                   agora.microsecond // 1000, _seq_versao)
+        with open(os.path.join(pasta, carimbo + ".json"), "w", encoding="utf-8") as fh:
+            json.dump(arq, fh, ensure_ascii=False)
+        antigas = sorted(n for n in os.listdir(pasta) if n.endswith(".json"))
+        for velha in antigas[:-MAX_VERSOES]:
+            os.remove(os.path.join(pasta, velha))
+        return carimbo
+    except Exception:
+        # Histórico é rede de proteção, não requisito: se o disco recusar, a
+        # gravação principal segue. Falhar aqui seria trocar perder o passado
+        # por perder o presente.
+        return None
+
+
+def versoes(arq_id):
+    """As versões guardadas, da mais nova para a mais velha."""
+    if not caminho(arq_id):
+        return []
+    pasta = os.path.join(VERSOES, arq_id)
+    if not os.path.isdir(pasta):
+        return []
+    saida = []
+    for nome in sorted(os.listdir(pasta), reverse=True):
+        if not nome.endswith(".json"):
+            continue
+        try:
+            with open(os.path.join(pasta, nome), encoding="utf-8") as fh:
+                a = json.load(fh)
+        except Exception:
+            continue
+        doc = a.get("doc") or {}
+        saida.append({
+            "versao": nome[:-5],
+            "titulo": a.get("titulo", ""),
+            "pecas": len(doc.get("cenas") or doc.get("blocos") or doc.get("abas") or []),
+            "atualizado": a.get("atualizado", ""),
+        })
+    return saida
+
+
+def ler_versao(arq_id, versao):
+    if not caminho(arq_id) or not re.fullmatch(r"[0-9A-Za-z\-]{1,40}", versao or ""):
+        return None
+    c = os.path.join(VERSOES, arq_id, versao + ".json")
+    if not os.path.exists(c):
+        return None
+    with open(c, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def _tem_narracao(doc):
+    if not isinstance(doc, dict):
+        return False
+    if isinstance(doc.get("narracao"), str) and doc["narracao"].strip():
+        return True
+    for c in doc.get("cenas") or []:
+        if isinstance(c, dict) and isinstance(c.get("narracao"), str) and c["narracao"].strip():
+            return True
+    return False
+
+
+def preparar_voz(doc):
+    """Documento com narração chegou: começa a baixar a voz agora.
+
+    O download é de ~90 MB e leva algum tempo. Fazê-lo quando o usuário
+    aperta play seria tarde — ele ouviria a voz robótica do Google. Fazê-lo
+    aqui, no instante em que o roteiro é gravado, dá ao download a mesma
+    janela que o agente gasta escrevendo o resto: quando alguém toca o vídeo,
+    a voz boa já está na máquina. Se não der tempo, a corrente cobre."""
+    if _tem_narracao(doc) and not voz_lib.pronta():
+        try:
+            voz_lib.instalar()
+        except Exception:
+            pass
+
+
+def mesclar(antigo, novo):
+    """O documento novo por cima do antigo, chave a chave.
+
+    Quem só quer trocar o tema manda {"tema":"papel"} — e é a coisa natural a
+    mandar, porque o pedido era esse. Trocar o documento inteiro por isso
+    apagava cenas, narração e trilha. Mesclando, o que não foi citado fica
+    onde estava e o que foi citado vale: mandar cenas novas ainda troca as
+    cenas, que é o ajuste de verdade."""
+    if not isinstance(antigo, dict) or not isinstance(novo, dict):
+        return novo
+    saida = dict(antigo)
+    saida.update(novo)
+    return saida
+
+
 def listar():
     saida = []
     for nome in os.listdir(ARQUIVOS):
@@ -269,6 +434,7 @@ def criar(dados):
         if problema:
             raise ValueError(problema)
 
+    preparar_voz(doc)
     arq_id = ferramenta + "-" + slugify(titulo) + "-" + uuid.uuid4().hex[:5]
     return gravar({
         "id": arq_id,
@@ -311,6 +477,22 @@ def _texto_do_doc(doc):
     return " ".join(pedacos).lower()
 
 
+# Os temas que o render.css de fato define. Fora desta lista não existe cor
+# nenhuma — foi o que aconteceu com "noite", que passou como se fosse tema.
+TEMAS_VALIDOS = {"claro", "meia-noite", "papel", "neon", "brasa", "floresta",
+                 "retro", "oceano", "doce", "mono"}
+
+
+def _tema_invalido(tema, onde=""):
+    if tema is None:
+        return None
+    if isinstance(tema, str) and tema in TEMAS_VALIDOS:
+        return None
+    return ('tema %r%s não existe — a peça sairia sem cor nenhuma. Os temas são: %s. '
+            'Para escuro use "meia-noite".'
+            % (tema, onde, ", ".join(sorted(TEMAS_VALIDOS))))
+
+
 def validar_doc(modelo, doc):
     """None quando o doc serve; senão, a frase que ENSINA o formato certo.
 
@@ -332,6 +514,13 @@ def validar_doc(modelo, doc):
     TIPOS_VALIDOS = {"texto", "lista", "cartoes", "numeros", "tabela", "codigo",
                      "citacao", "forma", "imagem", "icone", "grafico", "no", "conector"}
 
+    # Tema inventado tinha o mesmo destino silencioso do tipo inventado: o CSS
+    # não casa com [data-tema="noite"], nenhuma cor é definida e a peça sai
+    # sem identidade nenhuma. Recusar aqui devolve a lista certa ao agente.
+    problema = _tema_invalido(doc.get("tema"))
+    if problema:
+        return problema
+
     if modelo == "cena":
         cenas = doc.get("cenas")
         if not isinstance(cenas, list) or not cenas:
@@ -345,6 +534,9 @@ def validar_doc(modelo, doc):
             if not isinstance(els, list) or not els:
                 return ('cena %d sem "elementos". Cada cena precisa de elementos:[...] — '
                         'ex.: {"tipo":"texto","texto":"..."}. Leia studio_spec e refaça.' % (i + 1))
+            problema = _tema_invalido(c.get("tema"), " (cena %d)" % (i + 1))
+            if problema:
+                return problema
             dur = c.get("duracao")
             if dur is not None and not isinstance(dur, (int, float)):
                 return ('cena %d com "duracao" que não é número (veio %r). Use número de segundos: '
@@ -600,6 +792,12 @@ class Handler(SimpleHTTPRequestHandler):
             a = ler(m.group(1))
             return self.js(a) if a else self.js({"erro": "não encontrado"}, 404)
 
+        m = re.fullmatch(r"/api/arquivos/([^/]+)/versoes", p)
+        if m:
+            if not ler(m.group(1)):
+                return self.js({"erro": "não encontrado"}, 404)
+            return self.js({"versoes": versoes(m.group(1))})
+
         m = re.fullmatch(r"/api/arquivos/([^/]+)/export", p)
         if m:
             a = ler(m.group(1))
@@ -610,17 +808,25 @@ class Handler(SimpleHTTPRequestHandler):
         return super().do_GET()
 
     # ── Voz ────────────────────────────────────────────────────────────
-    # Ponte para o TTS do Google. Existe porque o Google não manda cabeçalho
-    # de CORS: do navegador direto o pedido morre, daqui funciona.
+    # A narração inteira é decidida AQUI, no Python, e não no navegador.
     #
-    # É a rede de segurança da narração. O caminho bom é a voz neural do Edge,
-    # que fala direto do navegador por WebSocket (sem CORS) e tem voz grave de
-    # verdade para vídeo; quando ela não sobe, cai aqui — uma voz só, sem
-    # escolha, mas que responde sempre.
+    # Antes o navegador tentava a voz neural do Edge por WebSocket e, quando
+    # ela não subia, caía no speechSynthesis — o TTS da própria máquina, que
+    # soa a computador. A voz do Edge parou de subir (a Microsoft responde
+    # 403 na síntese), então na prática TODO vídeo saía com voz de robô. Era
+    # o que o usuário estava ouvindo.
     #
-    # O endpoint recusa texto comprido, então a frase é cortada em pedaços de
-    # até 190 caracteres, sempre numa fronteira de palavra, e os MP3 são
-    # emendados. MP3 aceita concatenação de quadros: é feio, mas toca.
+    # A corrente agora é esta, e o navegador só consome o resultado:
+    #   1. PIPER    neural, roda na máquina, offline, ilimitado, com escolha
+    #               de voz — inclusive graves de verdade (voz.py mede e diz
+    #               a frequência de cada uma). É o bom.
+    #   2. VOICEBOX se o usuário tiver o app: voz clonável.
+    #   3. GOOGLE   uma voz só, robótica, mas responde na hora sem instalar
+    #               nada — é o que cobre enquanto o Piper baixa.
+    #
+    # O endpoint do Google recusa texto comprido, então a frase é cortada em
+    # pedaços de até 190 caracteres, sempre numa fronteira de palavra, e os
+    # MP3 são emendados. MP3 aceita concatenação de quadros: é feio, mas toca.
     def voz(self, query):
         from urllib.parse import parse_qs
         q = parse_qs(query or "")
@@ -631,22 +837,45 @@ class Handler(SimpleHTTPRequestHandler):
         if len(texto) > 4000:
             texto = texto[:4000]
 
-        voz = (q.get("voz", [""])[0] or "").strip()
+        voz_pedida = (q.get("voz", [""])[0] or "").strip()
         instrucao = (q.get("instrucao", [""])[0] or "").strip()
         motor = (q.get("motor", [""])[0] or "").strip()
+        grave = (q.get("grave", [""])[0] or "").lower() in ("1", "true", "sim")
+        try:
+            velocidade = float(q.get("velocidade", ["1"])[0])
+        except ValueError:
+            velocidade = 1.0
 
         tipo = "audio/mpeg"
         audio = b""
-        # 1) Voicebox, se o usuário tiver instalado: voz clonável, ilimitada e
+
+        # 1) Piper: o motor bom. Se ainda não baixou, começa a baixar agora e
+        #    segue para o próximo — quem pediu narração hoje ouve o Google, e
+        #    a partir da próxima já é voz de verdade.
+        if motor not in ("google", "voicebox"):
+            try:
+                if voz_lib.pronta(voz_pedida or None):
+                    audio = voz_lib.sintetizar(texto, voz_pedida or None,
+                                               grave=grave, velocidade=velocidade) or b""
+                    if audio:
+                        tipo = "audio/wav"
+                else:
+                    voz_lib.instalar(voz_pedida or None)
+            except Exception as e:
+                sys.stderr.write("[voz] Piper falhou (%s); seguindo a corrente\n" % e)
+                audio = b""
+
+        # 2) Voicebox, se o usuário tiver instalado: voz clonável, ilimitada e
         #    sem depender de nada na internet.
-        if motor != "google" and self._voicebox_vivo():
+        if not audio and motor != "google" and self._voicebox_vivo():
             try:
-                audio, tipo = self._voz_voicebox(texto, voz, instrucao)
+                audio, tipo = self._voz_voicebox(texto, voz_pedida, instrucao)
             except Exception as e:
                 sys.stderr.write("[voz] Voicebox falhou (%s); indo de Google\n" % e)
                 audio = b""
-        # 2) Google: uma voz só, mas responde sempre.
+        # 3) Google: uma voz só, mas responde sempre.
         if not audio:
+            tipo = "audio/mpeg"
             try:
                 audio = b"".join(self._trecho_de_voz(t, idioma) for t in _picar(texto, 190))
             except Exception as e:                  # rede, bloqueio, mudança do serviço
@@ -675,7 +904,8 @@ class Handler(SimpleHTTPRequestHandler):
 
     def voz_status(self):
         """O que está disponível para narrar, para a interface não oferecer o
-        que não existe."""
+        que não existe — e para ela poder mostrar o download em vez de fingir
+        que já está tudo pronto."""
         vivo = self._voicebox_vivo()
         vozes = []
         if vivo:
@@ -686,6 +916,7 @@ class Handler(SimpleHTTPRequestHandler):
             except Exception:
                 vozes = []
         return self.js({
+            "piper": voz_lib.estado(),
             "voicebox": {"ativo": vivo, "vozes": vozes, "site": "https://voicebox.sh"},
             "google": {"ativo": True},
         })
@@ -828,6 +1059,13 @@ class Handler(SimpleHTTPRequestHandler):
             corpo, status = guardar_midia(self.corpo())
             return self.js(corpo, status)
 
+        if rota == "/api/voz/instalar":
+            pedido = self.corpo()
+            if pedido.get("apagar"):
+                return self.js(voz_lib.apagar())
+            return self.js(voz_lib.instalar(pedido.get("voz"),
+                                            esperar=min(60, int(pedido.get("esperar") or 0))))
+
         if rota == "/api/sair":
             # Só o CLI chama, e só quando o código no disco mudou (update do
             # npm). Sem isto o processo antigo ficava no ar servindo o bug que
@@ -838,6 +1076,32 @@ class Handler(SimpleHTTPRequestHandler):
             threading.Thread(target=lambda: (time.sleep(0.3), os._exit(0)), daemon=True).start()
             return
 
+        m = re.fullmatch(r"/api/arquivos/([^/]+)/restaurar", rota)
+        if m:
+            a = ler(m.group(1))
+            if not a:
+                return self.js({"erro": "não encontrado"}, 404)
+            pedido = self.corpo()
+            disponiveis = versoes(m.group(1))
+            # Sem versão dita, a anterior — que é o que "desfaz" quer dizer
+            # quando alguém acabou de estragar o arquivo.
+            alvo = pedido.get("versao") or (disponiveis[0]["versao"] if disponiveis else None)
+            velha = ler_versao(m.group(1), alvo) if alvo else None
+            if not velha:
+                return self.js({"erro": "versão não encontrada",
+                                "versoes": disponiveis}, 404)
+            # Restaurar também guarda versão: desfazer o desfazer tem de valer.
+            guardar_versao(a)
+            a["titulo"] = velha.get("titulo", a.get("titulo"))
+            a["doc"] = velha.get("doc") or a.get("doc")
+            gravar(a)
+            doc = a.get("doc") or {}
+            return self.js({
+                "ok": True, "id": a["id"], "restaurado": alvo,
+                "titulo": a.get("titulo"),
+                "pecas": len(doc.get("cenas") or doc.get("blocos") or doc.get("abas") or []),
+            })
+
         if rota == "/api/arquivos":
             try:
                 a = criar(self.corpo())
@@ -873,10 +1137,37 @@ class Handler(SimpleHTTPRequestHandler):
             return self.js({"erro": "titulo precisa ser texto"}, 400)
         if "doc" in dados and dados["doc"] is not None and not isinstance(dados["doc"], dict):
             return self.js({"erro": "doc precisa ser um objeto"}, 400)
-        for chave in ("titulo", "doc"):
-            if chave in dados:
-                a[chave] = dados[chave]
-        return self.js(gravar(a))
+
+        antes = a.get("doc") or {}
+        novo = a.get("doc")
+        if "doc" in dados and dados["doc"] is not None:
+            # Mesclar em vez de trocar. Era aqui que o trabalho sumia: um doc
+            # parcial substituía o inteiro. Quem quiser mesmo jogar fora o que
+            # existe manda "substituir": true e assume.
+            novo = dados["doc"] if dados.get("substituir") else mesclar(antes, dados["doc"])
+
+            # O agente precisa da validação: é a única forma de ele saber que
+            # errou o formato. O editor do navegador, não — ali há uma pessoa
+            # digitando, e uma cena momentaneamente vazia no meio da edição não
+            # pode fazer o salvamento falhar calado.
+            if self.headers.get("X-Primo-Agente"):
+                problema = validar_doc(
+                    POR_SLUG.get(a.get("ferramenta"), {}).get("modelo"), novo)
+                if problema:
+                    return self.js({"erro": problema}, 400)
+
+        preparar_voz(novo)
+        versao = guardar_versao(a)
+        if "titulo" in dados:
+            a["titulo"] = dados["titulo"]
+        if "doc" in dados:
+            a["doc"] = novo
+        salvo = gravar(a)
+        if versao:
+            # O agente vê isto no resultado da tool: se ele estragou algo, o
+            # caminho de volta está na resposta, não numa doc que ele não leu.
+            salvo = dict(salvo, versao_anterior=versao)
+        return self.js(salvo)
 
     @seguro
     def do_DELETE(self):