vibeeditor-render 0.3.1 → 0.3.3

package/cli/vibeeditor-render.js

@@ -182,6 +182,35 @@ async function versaoNova() {
   return null;
 }
 
+/**
+ * Atualização ao abrir: se saiu versão nova no npm, troca por ela na hora (npx com o número exato, então a cópia
+ * guardada do npx não segura a antiga) e esta fica só esperando a nova fechar. Não roda em desenvolvimento (com o
+ * código-fonte do host ao lado) nem duas vezes seguidas (VIBE_RENDER_ATUALIZADO), e nunca trava a abertura:
+ * sem internet ou com o npm fora, segue na versão atual.
+ */
+async function atualizarSeTiver(argv) {
+  if (process.env.VIBE_RENDER_ATUALIZADO || process.env.VIBE_RENDER_SEM_ATUALIZAR) return false;
+  if (fs.existsSync(path.join(RAIZ, "host", "build.mjs"))) return false;
+  const nova = await versaoNova();
+  if (!nova) return false;
+  dizer(`${azul("›")} Saiu a versão ${negrito(nova)} (esta é a ${VERSAO}). Atualizando e abrindo a nova…`);
+  // no Windows o npx é um .cmd e precisa do shell: argumento com espaço (--pasta "C:\Meus Vídeos") vai entre aspas
+  const args = process.platform === "win32" ? argv.map((a) => (/[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a)) : argv;
+  const filho = spawn("npx", ["-y", `${PACOTE.name}@${nova}`, ...args], {
+    stdio: "inherit", shell: process.platform === "win32", env: {...process.env, VIBE_RENDER_ATUALIZADO: "1"},
+  });
+  // o Ctrl+C chega nos dois: quem cuida é a versão nova; esta só repassa o código de saída
+  process.on("SIGINT", () => {});
+  await new Promise((ok) => {
+    filho.on("error", (e) => {
+      dizer(`${ambar("!")} Não consegui atualizar (${e.message}). Sigo na ${VERSAO}.`);
+      ok(false);
+    });
+    filho.on("exit", (code) => process.exit(code == null ? 0 : code));
+  });
+  return false;
+}
+
 /** "1.10.0" é mais nova que "1.9.3"? (só números; pré-lançamentos não entram) */
 function maisNova(a, b) {
   const x = String(a).split(".").map(Number), y = String(b).split(".").map(Number);
@@ -255,7 +284,8 @@ async function principal() {
   }
 
   dizer(`\n${negrito(azul("▶ Vibe Render"))} ${cinza(`v${VERSAO}`)}  ${cinza("· exporta os vídeos do Editor IA neste computador")}\n`);
-  versaoNova().then((v) => v && dizer(`${ambar("!")} Saiu a versão ${v}. Feche e abra de novo com ${azul("npx vibeeditor-render@latest")}.`));
+  // versão nova no npm: abre direto nela (esta só espera); sem internet, segue nesta
+  await atualizarSeTiver(process.argv.slice(2));
 
   const {PORTAS} = require("../core/config");
   const outra = await jaAberto(PORTAS);

package/core/nucleo.js

@@ -28,6 +28,7 @@ async function criarNucleo(opc) {
   servidor = criarServidor({versao: opc.versao, origens: origensPermitidas(env), cache, jobs, transcricoes, voz, pareamento, mostrarArquivo: opc.mostrarArquivo, log: opc.log});
   const porta = await servidor.iniciar(opc.portas);
   pareamento.conferir();
+  voz.aoIniciar(); // abre o VoiceStudio junto, se a pessoa pediu (Configurações → VoiceStudio)
   const relogio = setInterval(() => pareamento.conferir(), STATUS_INTERVALO);
   relogio.unref();
   return {

package/core/servidor.js

@@ -116,7 +116,7 @@ function criarServidor(opc) {
       const p = opc.pareamento.visao();
       return json(200, {app: "vibe-render", versao: opc.versao, pareado: p.pareado, dispositivoId: p.dispositivoId, email: p.email,
         plataforma: process.platform, porta, acessoPlataforma: p.plataforma,
-        recursos: [...(opc.transcricoes ? ["transcricao"] : []), ...(opc.voz ? ["voz"] : [])]}, cors);
+        recursos: [...(opc.transcricoes ? ["transcricao"] : []), ...(opc.voz ? ["voz", "voz-abrir"] : [])]}, cors);
     }
 
     // daqui para baixo: sessão válida deste aparelho

package/core/voz.js

@@ -8,10 +8,14 @@
 //   POST /v1/voz/perfis              multipart → POST /profiles (clonar: name, kind, ref_audio, ref_text, language)
 //   POST /v1/voz/perfis/<id>/excluir → DELETE /profiles/<id> (a voz que já não existe conta como excluída)
 //   POST /v1/voz/gerar               multipart → POST /generate (text, profile_id ou ref_audio… → WAV)
+//   POST /v1/voz/abrir               abre o app do VoiceStudio instalado neste computador (o site espera ele subir)
+//   POST /v1/voz/preferencias {abrirJunto}   abre o VoiceStudio junto com o Vibe Render (que sobe com o computador)
 // Nada de IA aqui: gerar voz é determinístico. O formato das respostas do VoiceStudio muda entre versões, então
 // o status vai cru e quem interpreta é o site.
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
+const {spawn} = require("node:child_process");
 
 const URL_PADRAO = "http://127.0.0.1:3900";
 const HOSTS_LOCAIS = new Set(["127.0.0.1", "localhost", "[::1]"]);
@@ -35,6 +39,43 @@ function urlValida(bruta) {
 
 const erro = (status, mensagem, extra = {}) => Object.assign(new Error(mensagem), {status, ...extra});
 
+/** onde o instalador do VoiceStudio costuma pôr o app (Electron), em cada sistema */
+function lugaresDoApp(plataforma = process.platform, env = process.env, casa = os.homedir()) {
+  if (plataforma === "win32") {
+    const local = env.LOCALAPPDATA || path.join(casa, "AppData", "Local");
+    return [path.join(local, "Programs", "VoiceStudio", "VoiceStudio.exe"),
+      ...[env.ProgramFiles, env["ProgramFiles(x86)"]].filter(Boolean).map((p) => path.join(p, "VoiceStudio", "VoiceStudio.exe"))];
+  }
+  if (plataforma === "darwin") return ["/Applications/VoiceStudio.app", path.join(casa, "Applications", "VoiceStudio.app")];
+  const appimages = [path.join(casa, "Applications"), path.join(casa, "Downloads")].flatMap((d) => {
+    try {
+      return fs.readdirSync(d).filter((f) => /^voicestudio.*\.appimage$/i.test(f)).map((f) => path.join(d, f));
+    } catch {
+      return [];
+    }
+  });
+  return [...appimages, "/opt/VoiceStudio/voicestudio", "/usr/bin/voicestudio", "/usr/local/bin/voicestudio"];
+}
+
+/** só abre um arquivo que existe e se chama VoiceStudio: o site manda o pedido, nunca o caminho de outro programa */
+function appValido(caminho) {
+  if (!caminho || !path.isAbsolute(caminho) || !/voicestudio/i.test(path.basename(caminho))) return false;
+  try {
+    return fs.existsSync(caminho);
+  } catch {
+    return false;
+  }
+}
+
+/** abre o app sem prender o Vibe Render a ele (fecha um, o outro continua) */
+function abrirApp(caminho, plataforma = process.platform) {
+  const filho = plataforma === "darwin"
+    ? spawn("open", ["-a", caminho], {detached: true, stdio: "ignore"})
+    : spawn(caminho, [], {detached: true, stdio: "ignore", windowsHide: false, cwd: path.dirname(caminho)});
+  filho.on("error", () => {});
+  filho.unref();
+}
+
 /** lê o corpo inteiro até `max` bytes (413 acima disso) */
 function lerCorpo(req, max) {
   return new Promise((ok, falha) => {
@@ -76,13 +117,20 @@ function criarVoz(opc) {
   const log = opc.log || (() => {});
   const arq = path.join(opc.dirDados, ARQUIVO);
 
-  const salva = () => {
+  // voicestudio.json: {url, abrirJunto, app} — o endereço, se abre junto com o Vibe Render e onde está o app
+  const lerArq = () => {
     try {
-      return urlValida(JSON.parse(fs.readFileSync(arq, "utf8")).url);
+      const d = JSON.parse(fs.readFileSync(arq, "utf8"));
+      return d && typeof d === "object" ? d : {};
     } catch {
-      return null;
+      return {};
     }
   };
+  const gravarArq = (patch) => {
+    fs.mkdirSync(opc.dirDados, {recursive: true});
+    fs.writeFileSync(arq, JSON.stringify({...lerArq(), ...patch}, null, 2));
+  };
+  const salva = () => urlValida(lerArq().url);
   /** a variável de ambiente manda (fixo); senão o endereço guardado; senão o padrão do VoiceStudio */
   function config() {
     const daEnv = urlValida(env.VIBE_RENDER_VOICESTUDIO);
@@ -93,12 +141,40 @@ function criarVoz(opc) {
   function definir(bruta) {
     const url = urlValida(bruta);
     if (!url) throw erro(400, "Endereço inválido: use o do VoiceStudio neste computador, como http://127.0.0.1:3900");
-    fs.mkdirSync(opc.dirDados, {recursive: true});
-    fs.writeFileSync(arq, JSON.stringify({url}, null, 2));
+    gravarArq({url});
     return config();
   }
   if (opc.urlInicial) definir(opc.urlInicial);
 
+  /** o app instalado: o caminho guardado (se ainda existe) ou o primeiro lugar padrão onde ele está */
+  function acharApp() {
+    const guardado = lerArq().app;
+    if (appValido(guardado)) return guardado;
+    return (opc.lugares || lugaresDoApp(process.platform, env)).find(appValido) || null;
+  }
+  const preferencias = () => ({abrirJunto: lerArq().abrirJunto === true, app: acharApp()});
+
+  /** abre o VoiceStudio se estiver fechado; o site espera ele subir conferindo o status */
+  async function abrir() {
+    const st = await status();
+    if (st.online) return {jaAberto: true, app: acharApp()};
+    const app = acharApp();
+    if (!app) throw erro(404, "Não encontrei o VoiceStudio instalado neste computador. Instale uma vez (github.com/debpalash/VoiceStudio) e tente de novo.", {semApp: true});
+    (opc.abrirApp || abrirApp)(app);
+    gravarArq({app});
+    log("voz", `abrindo o VoiceStudio: ${app}`);
+    return {abrindo: true, app};
+  }
+
+  /** chamado quando o Vibe Render sobe: abre o VoiceStudio junto, se a pessoa pediu */
+  async function aoIniciar() {
+    if (!preferencias().abrirJunto) return null;
+    return abrir().catch((e) => {
+      log("voz", `não abri o VoiceStudio junto: ${e.message}`);
+      return null;
+    });
+  }
+
   /** um pedido ao VoiceStudio; erro com status 503 (fechado), 504 (demorou) ou o status dele */
   async function chamar(caminho, {metodo = "GET", corpo, tipo, timeout = 8000, sinal} = {}) {
     const {url} = config();
@@ -177,7 +253,19 @@ function criarVoz(opc) {
   async function rota(req, res, resto, {json, cors}) {
     const [a, b, c] = resto;
     try {
-      if (a === "config" && !b && req.method === "GET") return json(200, config(), cors), true;
+      if (a === "config" && !b && req.method === "GET") return json(200, {...config(), ...preferencias()}, cors), true;
+      if (a === "abrir" && !b && req.method === "POST") return json(200, await abrir(), cors), true;
+      if (a === "preferencias" && !b && req.method === "POST") {
+        let d;
+        try {
+          d = JSON.parse((await lerCorpo(req, 4096)).toString("utf8") || "{}");
+        } catch (e) {
+          throw e.status ? e : erro(400, "JSON inválido");
+        }
+        if (typeof (d && d.abrirJunto) !== "boolean") throw erro(400, "abrirJunto precisa ser true ou false");
+        gravarArq({abrirJunto: d.abrirJunto});
+        return json(200, preferencias(), cors), true;
+      }
       if (a === "config" && !b && req.method === "POST") {
         let d;
         try {
@@ -215,13 +303,13 @@ function criarVoz(opc) {
       if (e.status === 499) return res.destroy(), true;
       // 401/403 do VoiceStudio não podem parecer sessão inválida do Vibe Render (o site renovaria a sessão)
       const st = e.status === 401 || e.status === 403 ? 502 : e.status || 500;
-      json(st, {erro: e.status ? e.message : "erro interno", ...(e.offline ? {offline: true} : {}), ...(e.doVoiceStudio ? {voiceStudio: e.status} : {})}, cors);
+      json(st, {erro: e.status ? e.message : "erro interno", ...(e.offline ? {offline: true} : {}), ...(e.semApp ? {semApp: true} : {}), ...(e.doVoiceStudio ? {voiceStudio: e.status} : {})}, cors);
       if (!e.status) log("erro", e.message);
       return true;
     }
   }
 
-  return {config, definir, status, chamar, rota};
+  return {config, definir, status, chamar, rota, abrir, aoIniciar, preferencias, acharApp};
 }
 
-module.exports = {criarVoz, urlValida, URL_PADRAO, LIMITE_CORPO};
+module.exports = {criarVoz, urlValida, lugaresDoApp, appValido, URL_PADRAO, LIMITE_CORPO};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeeditor-render",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Vibe Render: exporta os vídeos do Editor IA (vibeeditor.com.br) no seu computador, com Remotion + Chrome Headless Shell.",
   "keywords": [
     "vibeeditor",