vibeeditor-render 0.3.0 → 0.3.2

package/cli/sistema.js

@@ -0,0 +1,158 @@
+// Integração com o sistema, para ninguém precisar abrir o Vibe Render na mão a cada vez que liga o computador:
+//  · início automático: sobe junto com o login (Windows: pasta Inicializar; Mac: LaunchAgent; Linux: autostart),
+//    minimizado e sem perguntar nada — o pareamento já fica salvo na pasta de dados;
+//  · link vibe-render://abrir: o botão "Abrir o Vibe Render" do site chama este link e o navegador pergunta
+//    "Abrir Vibe Render?" (Windows: registro do usuário; Linux: x-scheme-handler; Mac: um app pequeno em
+//    ~/Applications feito com o osacompile).
+// Tudo fica na conta do usuário (nada de administrador) e cada passo que falhar só é pulado.
+"use strict";
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const {spawnSync} = require("node:child_process");
+
+const PROTOCOLO = "vibe-render";
+const COMANDO = "npx -y vibeeditor-render@latest --sem-atalho --segundo-plano";
+
+const rodar = (cmd, args) => spawnSync(cmd, args, {encoding: "utf8", windowsHide: true});
+
+/** pasta especial do Windows (Startup, Desktop…), já com OneDrive e nome traduzido */
+function pastaWindows(qual) {
+  const r = rodar("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `[Environment]::GetFolderPath('${qual}')`]);
+  const p = String(r.stdout || "").trim();
+  return r.status === 0 && p ? p : null;
+}
+
+/** onde fica o arquivo do início automático em cada sistema */
+function arquivoInicio(plataforma = process.platform, casa = os.homedir(), env = process.env) {
+  if (plataforma === "win32") {
+    const startup = pastaWindows("Startup") || path.join(env.APPDATA || path.join(casa, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+    return path.join(startup, "Vibe Render.cmd");
+  }
+  if (plataforma === "darwin") return path.join(casa, "Library", "LaunchAgents", "br.com.vibeeditor.render.plist");
+  return path.join(env.XDG_CONFIG_HOME || path.join(casa, ".config"), "autostart", "vibeeditor-render.desktop");
+}
+
+/** conteúdo do arquivo do início automático (minimizado, sem pausa no fim) */
+function conteudoInicio(plataforma = process.platform, dirDados = "") {
+  if (plataforma === "win32") return `@echo off\r\nstart "Vibe Render" /min cmd /c "${COMANDO}"\r\n`;
+  if (plataforma === "darwin") {
+    const log = path.join(dirDados, "inicio.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>br.com.vibeeditor.render</string>
+  <key>ProgramArguments</key>
+  <array><string>/bin/bash</string><string>-lc</string><string>${COMANDO}</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${log}</string>
+  <key>StandardErrorPath</key><string>${log}</string>
+</dict>
+</plist>
+`;
+  }
+  return `[Desktop Entry]
+Type=Application
+Name=Vibe Render
+Comment=Exporta os vídeos do Editor IA neste computador
+Exec=bash -lc "${COMANDO}"
+Terminal=false
+X-GNOME-Autostart-enabled=true
+`;
+}
+
+function ligarInicio({dirDados}) {
+  const arq = arquivoInicio();
+  fs.mkdirSync(path.dirname(arq), {recursive: true});
+  fs.writeFileSync(arq, conteudoInicio(process.platform, dirDados), {mode: 0o644});
+  return arq;
+}
+
+function desligarInicio() {
+  const arq = arquivoInicio();
+  const tinha = fs.existsSync(arq);
+  fs.rmSync(arq, {force: true});
+  return tinha;
+}
+
+const inicioLigado = () => fs.existsSync(arquivoInicio());
+
+/** o link vibe-render://abrir chama este iniciador (Windows/Linux); abre visível, mas sem segurar a janela */
+function registrarProtocolo({dirDados}) {
+  if (process.platform === "win32") {
+    const iniciador = path.join(dirDados, "abrir.cmd");
+    fs.writeFileSync(iniciador, `@echo off\r\nstart "Vibe Render" cmd /c "npx -y vibeeditor-render@latest --sem-atalho"\r\n`);
+    const chave = `HKCU\\Software\\Classes\\${PROTOCOLO}`;
+    const passos = [
+      ["add", chave, "/ve", "/d", "URL:Vibe Render", "/f"],
+      ["add", chave, "/v", "URL Protocol", "/d", "", "/f"],
+      ["add", `${chave}\\shell\\open\\command`, "/ve", "/d", `"${iniciador}" "%1"`, "/f"],
+    ];
+    for (const p of passos) {
+      const r = rodar("reg.exe", p);
+      if (r.status !== 0) throw new Error(`não consegui registrar o link (${String(r.stderr || r.stdout).trim()})`);
+    }
+    return `${PROTOCOLO}:// → ${iniciador}`;
+  }
+  if (process.platform === "darwin") {
+    // app de AppleScript que recebe o link e sobe o Vibe Render em segundo plano
+    const app = path.join(os.homedir(), "Applications", "Vibe Render.app");
+    fs.mkdirSync(path.dirname(app), {recursive: true});
+    const log = path.join(dirDados, "abrir.log");
+    const script = [
+      "on open location u",
+      `  do shell script "/bin/bash -lc 'nohup ${COMANDO.replace("--segundo-plano", "")} > \\"${log}\\" 2>&1 &'"`,
+      "end open location",
+      "on run",
+      `  do shell script "/bin/bash -lc 'nohup ${COMANDO.replace("--segundo-plano", "")} > \\"${log}\\" 2>&1 &'"`,
+      "end run",
+    ];
+    fs.rmSync(app, {recursive: true, force: true});
+    const r = rodar("osacompile", ["-o", app, ...script.flatMap((l) => ["-e", l])]);
+    if (r.status !== 0) throw new Error(`osacompile falhou (${String(r.stderr).trim()})`);
+    const plist = path.join(app, "Contents", "Info.plist");
+    for (const a of [
+      "Add :CFBundleIdentifier string br.com.vibeeditor.render.link",
+      "Add :CFBundleURLTypes array", "Add :CFBundleURLTypes:0 dict",
+      "Add :CFBundleURLTypes:0:CFBundleURLName string Vibe Render",
+      "Add :CFBundleURLTypes:0:CFBundleURLSchemes array",
+      `Add :CFBundleURLTypes:0:CFBundleURLSchemes:0 string ${PROTOCOLO}`,
+    ]) rodar("/usr/libexec/PlistBuddy", ["-c", a, plist]);
+    rodar("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", app]);
+    return `${PROTOCOLO}:// → ${app}`;
+  }
+  const apps = path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "applications");
+  fs.mkdirSync(apps, {recursive: true});
+  const desk = path.join(apps, "vibeeditor-render-link.desktop");
+  fs.writeFileSync(desk, `[Desktop Entry]
+Type=Application
+Name=Vibe Render
+Exec=bash -lc "npx -y vibeeditor-render@latest --sem-atalho" %u
+Terminal=true
+NoDisplay=true
+MimeType=x-scheme-handler/${PROTOCOLO};
+`);
+  rodar("xdg-mime", ["default", "vibeeditor-render-link.desktop", `x-scheme-handler/${PROTOCOLO}`]);
+  return `${PROTOCOLO}:// → ${desk}`;
+}
+
+/** liga tudo de uma vez; devolve o que deu certo e o que foi pulado (com o motivo) */
+function integrar({dirDados, inicio = true}) {
+  const feito = [], pulado = [];
+  try {
+    feito.push(`link ${registrarProtocolo({dirDados})}`);
+  } catch (e) {
+    pulado.push(`link vibe-render:// (${e.message})`);
+  }
+  if (inicio) {
+    try {
+      feito.push(`início automático em ${ligarInicio({dirDados})}`);
+    } catch (e) {
+      pulado.push(`início automático (${e.message})`);
+    }
+  }
+  return {feito, pulado};
+}
+
+module.exports = {integrar, ligarInicio, desligarInicio, inicioLigado, registrarProtocolo, arquivoInicio, conteudoInicio, PROTOCOLO, COMANDO};

package/cli/vibeeditor-render.js

@@ -8,7 +8,9 @@
 //   vibeeditor-render --pasta <dir>   muda a pasta onde os vídeos são salvos (fica guardada)
 //   vibeeditor-render --voicestudio <url>   endereço do VoiceStudio deste computador (fica guardado)
 //   vibeeditor-render desparear      desliga este computador da conta
-//   vibeeditor-render atalho          (re)cria o atalho "Vibe Render" na área de trabalho
+//   vibeeditor-render atalho          (re)cria o atalho "Vibe Render", o link vibe-render:// e o início automático
+//   vibeeditor-render sem-inicio-automatico   não abre mais junto com o computador
+//   vibeeditor-render --segundo-plano  como o início automático chama: minimizado, sem perguntar nada
 "use strict";
 const fs = require("node:fs");
 const os = require("node:os");
@@ -20,6 +22,8 @@ const PACOTE = require("../package.json");
 const VERSAO = PACOTE.version;
 const RAIZ = path.join(__dirname, "..");
 const SITE = "https://plat.vibeeditor.com.br/editor/render";
+const sistema = require("./sistema");
+const VERSAO_INTEGRACAO = 1; // sobe quando o que sistema.integrar() faz mudar
 
 // ------------------------------------------------------------------ terminal
 
@@ -38,7 +42,8 @@ ${negrito("Vibe Render")} ${cinza(`v${VERSAO}`)} · exporta os vídeos do Editor
   ${azul("npx vibeeditor-render@latest --pasta \"C:\\Videos\"")}   muda a pasta dos vídeos
   ${azul("npx vibeeditor-render@latest --voicestudio http://127.0.0.1:3900")}   endereço do VoiceStudio (voz clonada)
   ${azul("npx vibeeditor-render@latest desparear")}    desliga este computador da sua conta
-  ${azul("npx vibeeditor-render@latest atalho")}       cria o atalho na área de trabalho
+  ${azul("npx vibeeditor-render@latest atalho")}       atalho, botão "Abrir" do site e início junto com o computador
+  ${azul("npx vibeeditor-render@latest sem-inicio-automatico")}   não abre mais junto com o computador
 
 Deixe a janela aberta enquanto exporta. Para fechar: Ctrl+C.
 Ajuda: ${SITE}
@@ -46,7 +51,7 @@ Ajuda: ${SITE}
 }
 
 function lerArgs(argv) {
-  const a = {comando: null, codigo: null, pasta: null, voicestudio: null, semAtalho: false};
+  const a = {comando: null, codigo: null, pasta: null, voicestudio: null, semAtalho: false, segundoPlano: false};
   for (let i = 0; i < argv.length; i++) {
     const v = argv[i];
     if (v === "--codigo" || v === "-c") a.codigo = argv[++i] || "";
@@ -56,6 +61,7 @@ function lerArgs(argv) {
     else if (v === "--voicestudio") a.voicestudio = argv[++i] || "";
     else if (v.startsWith("--voicestudio=")) a.voicestudio = v.slice(14);
     else if (v === "--sem-atalho") a.semAtalho = true;
+    else if (v === "--segundo-plano") a.segundoPlano = true;
     else if (v === "--versao" || v === "-v" || v === "--version") a.comando = "versao";
     else if (v === "--ajuda" || v === "-h" || v === "--help") a.comando = "ajuda";
     else if (!v.startsWith("-") && !a.comando) a.comando = v;
@@ -204,7 +210,7 @@ async function principal() {
   const args = lerArgs(process.argv.slice(2));
   if (args.comando === "versao") return dizer(VERSAO);
   if (args.comando === "ajuda") return ajuda();
-  if (args.comando && !["desparear", "atalho"].includes(args.comando)) throw new Error(`não conheço o comando "${args.comando}". Veja: npx vibeeditor-render --ajuda`);
+  if (args.comando && !["desparear", "atalho", "sem-inicio-automatico"].includes(args.comando)) throw new Error(`não conheço o comando "${args.comando}". Veja: npx vibeeditor-render --ajuda`);
 
   const [maior] = process.versions.node.split(".").map(Number);
   if (maior < 20) throw new Error(`o Vibe Render precisa do Node.js 20 ou mais novo (este computador tem ${process.version}). Atualize em https://nodejs.org`);
@@ -228,7 +234,18 @@ async function principal() {
   }
   if (args.comando === "atalho") {
     const a = criarAtalho();
-    return dizer(a ? `${verde("✓")} Atalho criado: ${a}` : "Atalho só no Windows e no Mac. Aqui, rode: npx vibeeditor-render@latest");
+    dizer(a ? `${verde("✓")} Atalho criado: ${a}` : "Atalho na área de trabalho só no Windows e no Mac.");
+    config = {...config, semInicio: false};
+    const r = sistema.integrar({dirDados: dados});
+    for (const f of r.feito) dizer(`${verde("✓")} ${f}`);
+    for (const p of r.pulado) dizer(`${ambar("!")} Pulei: ${p}`);
+    config = {...config, atalhoCriado: true, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+    return;
+  }
+  if (args.comando === "sem-inicio-automatico") {
+    const tinha = sistema.desligarInicio();
+    config = {...config, semInicio: true, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+    return dizer(tinha ? `${verde("✓")} O Vibe Render não abre mais junto com o computador. Para voltar: npx vibeeditor-render@latest atalho` : "O início automático já estava desligado.");
   }
   if (args.pasta) {
     config = {...config, dirSaida: path.resolve(args.pasta)}; gravarConfig();
@@ -243,7 +260,7 @@ async function principal() {
   const {PORTAS} = require("../core/config");
   const outra = await jaAberto(PORTAS);
   if (outra) {
-    dizer(`${ambar("!")} O Vibe Render já está aberto em outra janela (porta ${outra}). Use aquela.`);
+    if (!args.segundoPlano) dizer(`${ambar("!")} O Vibe Render já está aberto em outra janela (porta ${outra}). Use aquela.`);
     return;
   }
 
@@ -262,6 +279,15 @@ async function principal() {
     mostrarArquivo, log, voiceStudio: args.voicestudio || null,
   });
 
+  // link vibe-render:// (botão "Abrir" do site) e início junto com o computador: uma vez por versão da
+  // integração, também para quem já abria pelo atalho antigo (que passa --sem-atalho)
+  if (config.integrado !== VERSAO_INTEGRACAO) {
+    const r = sistema.integrar({dirDados: dados, inicio: !config.semInicio});
+    if (r.feito.length) dizer(`${verde("✓")} Daqui para a frente o Vibe Render abre sozinho junto com o computador, e o site consegue abri-lo pelo botão. ${cinza("(para desligar: npx vibeeditor-render@latest sem-inicio-automatico)")}`);
+    for (const p of r.pulado) log("integração pulada:", p);
+    config = {...config, integrado: VERSAO_INTEGRACAO}; gravarConfig();
+  }
+
   // atalho na área de trabalho, uma vez (quem abriu pelo atalho passa --sem-atalho)
   if (!args.semAtalho && !config.atalhoCriado) {
     try {

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.0",
+  "version": "0.3.2",
   "description": "Vibe Render: exporta os vídeos do Editor IA (vibeeditor.com.br) no seu computador, com Remotion + Chrome Headless Shell.",
   "keywords": [
     "vibeeditor",