primocode 11.3.0 → 11.3.1

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v11.3.0
+# PrimoCode v11.3.1
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v11.3.0
+ ▐▛███▜▌   Primo Code v11.3.1
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/app-server/cli.js

@@ -41,7 +41,10 @@ async function main(args) {
     const contaFalsa = process.env.PRIMOCODE_CONTA_FALSA;
     // PRIMOCODE_TRANSCRITOR_FALSO=<arquivo.js>: async (wav) => ({ ok, texto }) no lugar do Whisper local. Só para teste de tela.
     const transcritorFalso = process.env.PRIMOCODE_TRANSCRITOR_FALSO;
+    // PRIMOCODE_FALA_FALSA=<arquivo.js>: { falar(texto) -> {ok,arquivo,mime}, aquecer(), disponivel() } no lugar da voz local. Só para teste.
+    const falaFalsa = process.env.PRIMOCODE_FALA_FALSA;
     const srv = criarServidor({
+        ...(falaFalsa ? { falaViva: require(require('path').resolve(falaFalsa)) } : {}),
         ...(transcritorFalso ? { transcritor: require(require('path').resolve(transcritorFalso)) } : {}),
         ...(falso ? { motor: require(require('path').resolve(falso)) } : {}),
         ...(contaFalsa ? { conta: require(require('path').resolve(contaFalsa)) } : {}),

package/lib/app-server/servidor.js

@@ -37,6 +37,7 @@ const PAREADO_PODE = new Set([
     'account/status',   // só ver se há conta; entrar, sair e o login pelo navegador são do computador
     'project/create', 'project/update', 'project/delete', 'agent/create', 'agent/update', 'agent/delete', 'agent/toggle',
     'brand/read', 'brand/write', 'config/write', 'voice/start', 'voice/stop', 'voice/transcribe',
+    'voice/warm', 'voice/frases', 'voice/speak',   // modo voz ao vivo do celular: só gera áudio e devolve ao celular, nunca toca no computador
 ]);
 const CAMPOS_CONFIG_PAREADO = ['effort', 'userName', 'mascot', 'reacoes', 'theme', 'preferencias'];
 const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
@@ -62,7 +63,7 @@ function githubConectado() {
     } catch { return null; }
 }
 
-function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {}, transcritor } = {}) {
+function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {}, transcritor, falaViva } = {}) {
     const cfg = require('../config/config');
     const m = motor || require('../motor');
     const base = casa || cfg.CONFIG_DIR;
@@ -82,6 +83,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
     const Marca = require('../plugin/marca-kit');
     const Piloto = require('../piloto');
     const Voz = voz || require('../motor/voz').criarVoz({ pasta: path.join(base, 'voz') });
+    let Fala = falaViva || null;   // a boca do modo voz ao vivo (lib/motor/fala-viva.js), criada só quando alguém fala
+    const falaDoModoVoz = () => (Fala = Fala || require('../motor/fala-viva').criarFalaViva({ pasta: path.join(base, 'voz') }));
     let loginNavegador = null;
     const statusConta = () => {
         const a = Conta.atual();
@@ -522,6 +525,24 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         /* ── Voz (6.9): provedor trocável em lib/motor/voz.js; só gera arquivo, nunca toca ── */
         async 'voice/start'(p, conn) { return Voz.iniciar({ texto: conn && conn.pareado ? undefined : p && p.texto }); },   // o celular não manda o computador falar
         'voice/stop'() { return Voz.parar(); },
+        /* Modo voz ao vivo: abrir a tela sobe o Whisper e o Kokoro em segundo plano (modelo carregado antes da primeira fala). */
+        'voice/warm'() {
+            if (!transcritor) require('../motor/transcricao').aquecer().catch(() => {});
+            falaDoModoVoz().aquecer().catch(() => {});
+            return { ok: true, fala: falaDoModoVoz().disponivel() };
+        },
+        /* A resposta do Primo em frases curtas para falar (sem markdown, código, caminho nem link). */
+        'voice/frases'(p) { return { frases: require('../motor/fala-viva').frasesParaFalar(p && p.texto, { max: 6 }) }; },
+        /* Uma frase vira áudio (arquivo gerado e devolvido em base64). Nunca toca: quem toca é a tela. */
+        async 'voice/speak'(p) {
+            const f = falaDoModoVoz();
+            const r = await f.falar(p && p.texto);
+            if (!r.ok) return { ok: false, error: r.error };
+            let audio;
+            try { audio = fs.readFileSync(r.arquivo).toString('base64'); } catch (e) { return { ok: false, error: `não li o áudio: ${e.message}` }; }
+            try { fs.rmSync(r.arquivo, { force: true }); } catch { /* sem arquivo */ }
+            return { ok: true, audio, mime: r.mime || 'audio/wav', provedor: r.provedor, ms: r.ms };
+        },
         /* Escuta (bug 3): o renderer grava (MediaRecorder), manda o WAV em base64 e recebe o texto. Whisper local; sem rede. */
         async 'voice/transcribe'(p) {
             const T = require('../motor/transcricao');
@@ -794,6 +815,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         if (timerPiloto) { clearInterval(timerPiloto); timerPiloto = null; }
         for (const c of [...conexoes]) if (c.fechar) c.fechar();
         conexoes.clear();
+        if (!transcritor) { try { require('../motor/transcricao').parar(); } catch { /* sem whisper vivo */ } }
+        if (Fala && Fala.parar) { try { Fala.parar(); } catch { /* sem voz viva */ } }
         try { if (porta && JSON.parse(fs.readFileSync(arquivoInfo, 'utf8')).token === token) fs.rmSync(arquivoInfo, { force: true }); } catch { /* nada a limpar */ }
         if (redeSrv) { try { redeSrv.close(); redeSrv.closeAllConnections && redeSrv.closeAllConnections(); } catch { /* já fechou */ } redeSrv = null; }
         return new Promise((res) => { if (http_) { http_.close(() => res()); http_.closeAllConnections && http_.closeAllConnections(); } else res(); });

package/lib/motor/fala-viva.js

@@ -0,0 +1,77 @@
+// A boca do modo voz ao vivo: o texto de uma frase vira um arquivo de áudio (WAV/AIFF). NUNCA toca som: devolve o arquivo,
+// e quem toca é a tela (que, no teste, desvia o player). Cadeia: Kokoro local em processo vivo (modelo carregado uma vez, sem
+// provedor pago) -> `say` do macOS -> espeak-ng. Só entra o que a máquina tem.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync, spawn } = require('child_process');
+const { criarProcessoVivo } = require('./processo-vivo');
+const K = require('../plugin/estudio/kokoro');
+
+const SCRIPT_VIVO = path.join(__dirname, '..', '..', 'studio', 'voz_kokoro_vivo.py');
+const TETO_FRASE = 500;
+
+const achar = (nome) => { try { return execFileSync('which', [nome], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; } catch { return null; } };
+
+/** Frases que vão pro ouvido: sem markdown, código, caminho nem link; no máximo `max` frases curtas. */
+function frasesParaFalar(texto, { max = 6 } = {}) {
+    const { paraFalar } = require('../plugin/voz');
+    const limpo = paraFalar(texto, { frases: max, teto: 900 });
+    const partes = limpo.match(/[^.!?…]+[.!?…]*/g) || [];
+    const out = [];
+    for (const p of partes) { const t = p.replace(/\s+/g, ' ').trim(); if (t.length > 1) out.push(t.slice(0, TETO_FRASE)); }
+    return out;
+}
+
+function criarFalaViva({ pasta, uv, voz = 'pf_dora', provedores } = {}) {
+    const dir = pasta || path.join(os.tmpdir(), 'primocode-voz');
+    let n = 0;
+    const arq = (ext) => { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); return path.join(dir, `frase-${Date.now()}-${++n}.${ext}`); };
+
+    let kokoro = null;
+    const kokoroVivo = () => {
+        if (kokoro) return kokoro;
+        const u = uv || achar('uv') || (fs.existsSync(path.join(os.homedir(), '.local', 'bin', 'uv')) ? path.join(os.homedir(), '.local', 'bin', 'uv') : null);
+        const esp = K.acharEspeak();
+        if (!u || !esp || !fs.existsSync(SCRIPT_VIVO)) return null;
+        const args = ['run', '--quiet', '--python', '3.11'];
+        for (const d of K.DEPS) args.push('--with', d);
+        args.push('python', SCRIPT_VIVO);
+        kokoro = criarProcessoVivo({ cmd: u, args, env: { ...process.env, ESPEAK_DATA_PATH: esp.dados, PHONEMIZER_ESPEAK_LIBRARY: esp.lib }, tempoPronto: 15 * 60000, tempoPedido: 60000 });
+        return kokoro;
+    };
+
+    const cadeia = provedores || [
+        { nome: 'kokoro', disponivel: () => !!kokoroVivo() && process.env.PRIMOCODE_VOZ !== 'say',
+            async falar(texto) { const o = arq('wav'); const r = await kokoroVivo().pedir({ texto, saida: o, voz }); return r.ok ? { ok: true, arquivo: o, mime: 'audio/wav' } : { ok: false, error: r.error }; } },
+        { nome: 'say', disponivel: () => process.platform === 'darwin' && !!achar('say'),
+            falar: (texto) => new Promise((res) => { const o = arq('aiff'); const p = spawn('say', ['-v', 'Luciana', '-o', o, texto]); p.on('error', (e) => res({ ok: false, error: e.message })); p.on('close', (c) => res(c === 0 && fs.existsSync(o) ? { ok: true, arquivo: o, mime: 'audio/aiff' } : { ok: false, error: 'o say não gerou o áudio' })); }) },
+        { nome: 'espeak-ng', disponivel: () => !!achar('espeak-ng'),
+            falar: (texto) => new Promise((res) => { const o = arq('wav'); const p = spawn('espeak-ng', ['-v', 'pt-br', '-w', o, texto]); p.on('error', (e) => res({ ok: false, error: e.message })); p.on('close', (c) => res(c === 0 && fs.existsSync(o) ? { ok: true, arquivo: o, mime: 'audio/wav' } : { ok: false, error: 'o espeak-ng não gerou o áudio' })); }) },
+    ];
+
+    return {
+        /** Sobe o Kokoro em segundo plano (modelo carregado antes da primeira frase). */
+        aquecer() { const k = cadeia[0].nome === 'kokoro' && cadeia[0].disponivel() ? kokoroVivo() : null; return k ? k.aquecer() : Promise.resolve({ ok: false }); },
+        disponivel() { return cadeia.find((p) => p.disponivel()) ? { ok: true, provedor: cadeia.find((p) => p.disponivel()).nome } : { ok: false, motivo: 'sem voz local: instale o uv e o espeak-ng (brew install uv espeak-ng) e rode `primocode doutor`' }; },
+        /** Uma frase vira áudio. Devolve {ok, arquivo, mime, provedor, ms} (nunca rejeita). */
+        async falar(texto) {
+            const t0 = Date.now();
+            const frase = String(texto || '').trim().slice(0, TETO_FRASE);
+            if (!frase) return { ok: false, error: 'falta texto' };
+            let ultimo = 'sem voz local: instale o uv e o espeak-ng (brew install uv espeak-ng) e rode `primocode doutor`';
+            for (const p of cadeia) {
+                if (!p.disponivel()) continue;
+                const r = await p.falar(K.pronuncia(frase));
+                if (r.ok) return { ...r, provedor: p.nome, ms: Date.now() - t0 };
+                ultimo = r.error || ultimo;
+            }
+            return { ok: false, error: ultimo };
+        },
+        parar() { if (kokoro) { kokoro.parar(); kokoro = null; } },
+    };
+}
+
+module.exports = { criarFalaViva, frasesParaFalar };

package/lib/motor/processo-vivo.js

@@ -0,0 +1,66 @@
+// Um processo filho que fica VIVO e conversa por linhas de JSON (uma linha entra, uma linha sai, casadas pelo `id`).
+// Serve ao modo voz ao vivo: o Whisper e o Kokoro carregam o modelo uma vez e respondem de pé, sem subir um processo por trecho.
+// Nunca toca som. Sobe na primeira chamada; `pronto` espera a linha {"pronto":true}; se o filho cai, o próximo pedido sobe outro.
+'use strict';
+
+const { spawn } = require('child_process');
+
+function criarProcessoVivo({ cmd, args = [], env, cwd, tempoPronto = 180000, tempoPedido = 120000 } = {}) {
+    let filho = null, pronto = null, buf = '', id = 0;
+    const pend = new Map();
+
+    function soltarTudo(erro) { for (const p of pend.values()) { clearTimeout(p.t); p.res({ ok: false, error: erro }); } pend.clear(); }
+
+    function subir() {
+        if (filho && pronto) return pronto;
+        buf = '';
+        filho = spawn(cmd, args, { env: env || process.env, cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        const meu = filho;
+        let erro = '';
+        meu.stderr.on('data', (d) => { erro = (erro + d).slice(-600); });
+        pronto = new Promise((resolve) => {
+            const t = setTimeout(() => resolve({ ok: false, error: 'o processo de voz demorou demais para ficar pronto' }), tempoPronto);
+            meu.stdout.on('data', (d) => {
+                buf += d;
+                let i;
+                while ((i = buf.indexOf('\n')) >= 0) {
+                    const linha = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+                    if (!linha) continue;
+                    let m; try { m = JSON.parse(linha); } catch { continue; }
+                    if (m.pronto) { clearTimeout(t); resolve({ ok: true }); continue; }
+                    if (m.id === undefined || m.id === null) { if (m.ok === false) { clearTimeout(t); resolve({ ok: false, error: m.error || 'o processo de voz não subiu' }); } continue; }
+                    const p = pend.get(m.id);
+                    if (p) { pend.delete(m.id); clearTimeout(p.t); p.res(m); }
+                }
+            });
+            meu.on('error', (e) => { clearTimeout(t); resolve({ ok: false, error: e.message }); });
+            meu.on('close', () => {
+                clearTimeout(t);
+                const era = filho === meu;
+                if (era) { filho = null; pronto = null; }
+                resolve({ ok: false, error: erro.trim().split('\n').pop() || 'o processo de voz saiu' });
+                soltarTudo('o processo de voz saiu');
+            });
+        });
+        return pronto;
+    }
+
+    return {
+        /** Sobe (se preciso) e espera ficar pronto. Devolve {ok} ou {ok:false,error}. */
+        async aquecer() { const r = await subir(); if (!r.ok) { this.parar(); } return r; },
+        async pedir(dados) {
+            const r = await subir();
+            if (!r.ok) { this.parar(); return r; }
+            return new Promise((res) => {
+                const n = ++id;
+                const t = setTimeout(() => { pend.delete(n); res({ ok: false, error: 'a voz demorou demais' }); }, tempoPedido);
+                pend.set(n, { res, t });
+                try { filho.stdin.write(`${JSON.stringify({ ...dados, id: n })}\n`); } catch (e) { pend.delete(n); clearTimeout(t); res({ ok: false, error: e.message }); }
+            });
+        },
+        parar() { const f = filho; filho = null; pronto = null; if (f) { try { f.kill('SIGTERM'); } catch { /* já saiu */ } } soltarTudo('parado'); },
+        vivo: () => !!filho,
+    };
+}
+
+module.exports = { criarProcessoVivo };

package/lib/motor/transcricao.js

@@ -7,6 +7,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawn, execFileSync } = require('child_process');
+const { criarProcessoVivo } = require('./processo-vivo');
 
 const PASTA_VOZ = path.join(__dirname, '..', '..', 'voz');
 const TETO_BYTES = 11 * 1024 * 1024;     // ~5 min de WAV 16 kHz mono (em base64 cabe no teto de 16 MB do WebSocket)
@@ -40,8 +41,31 @@ function transcrever(wav, { python: py, idioma = 'pt', tempoMs = TEMPO_MS } = {}
     });
 }
 
+/* O Whisper VIVO (modo voz ao vivo): um processo Python que carrega o modelo uma vez e transcreve arquivo por arquivo. */
+let vivo = null;
+function whisperVivo(py) {
+    if (!vivo) vivo = criarProcessoVivo({ cmd: py, args: ['-m', 'primo_voz.transcrever', 'servir', 'pt'], cwd: PASTA_VOZ, env: { ...process.env, PYTHONPATH: PASTA_VOZ } });
+    return vivo;
+}
+/** Sobe o Whisper em segundo plano (o modelo carrega antes da primeira fala). Nunca rejeita. */
+function aquecer({ python: py } = {}) {
+    py = py || require('../plugin/voz').python();
+    if (faltaAlgo(py)) return Promise.resolve({ ok: false });
+    return whisperVivo(py).aquecer();
+}
+function parar() { if (vivo) { vivo.parar(); vivo = null; } }
+/** Igual a `transcrever`, mas no processo vivo; se ele não sobe, cai no processo avulso. */
+async function transcreverVivo(wav, opts = {}) {
+    const py = opts.python || require('../plugin/voz').python();
+    const falta = faltaAlgo(py);
+    if (falta) return { ok: false, ...falta };
+    const r = await whisperVivo(py).pedir({ arquivo: wav });
+    if (r.ok) return { ok: true, texto: String(r.texto || '') };
+    return transcrever(wav, { python: py });
+}
+
 /** Grava o áudio (base64, WAV) num arquivo temporário, transcreve e apaga. `transcritor` troca o Whisper (teste). */
-async function transcreverBase64(audio, { pasta, transcritor = transcrever } = {}) {
+async function transcreverBase64(audio, { pasta, transcritor = transcreverVivo } = {}) {
     if (typeof audio !== 'string' || !audio) return { ok: false, error: 'falta o áudio' };
     const bytes = Buffer.from(audio, 'base64');
     if (!bytes.length) return { ok: false, error: 'áudio vazio' };
@@ -54,4 +78,4 @@ async function transcreverBase64(audio, { pasta, transcritor = transcrever } = {
     try { return await transcritor(arq); } finally { try { fs.rmSync(arq, { force: true }); } catch { /* sem arquivo */ } }
 }
 
-module.exports = { transcrever, transcreverBase64, faltaAlgo, TETO_BYTES };
+module.exports = { transcrever, transcreverVivo, transcreverBase64, aquecer, parar, faltaAlgo, TETO_BYTES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "11.3.0",
+  "version": "11.3.1",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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": {
@@ -11,7 +11,7 @@
     "postinstall": "node lib/preparar.js || true",
     "test:server": "cd server && npm test",
     "test": "node scripts/testes.js",
-    "test:app": "node test/app-fluxo.test.mjs && node test/app-primeira.test.mjs && node test/app-entrar.test.mjs && node test/app-tela-estudio.test.mjs && node test/app-celular-telas.test.mjs",
+    "test:app": "node test/app-fluxo.test.mjs && node test/app-primeira.test.mjs && node test/app-entrar.test.mjs && node test/app-tela-estudio.test.mjs && node test/app-celular-telas.test.mjs && node test/app-compositor-voz.test.mjs",
     "app:build": "cd app && npm run dist",
     "app:dev": "cd app && npm start",
     "mobile:build": "cd mobile && npm run build"

package/studio/voz_kokoro_vivo.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""voz_kokoro_vivo.py - a voz local do modo voz ao vivo: o Kokoro-82M fica CARREGADO e fala frase por frase.
+
+Entrada (uma linha de JSON por pedido): {"id": 1, "texto": "Oi.", "saida": "/tmp/x.wav", "voz": "pf_dora"}
+Saída (uma linha por resposta):          {"id": 1, "ok": true, "arquivo": "/tmp/x.wav", "segundos": 1.2}
+Primeira linha de saída: {"pronto": true}. Só GERA arquivo WAV; nunca toca som. Roda pelo uv (lib/motor/fala-viva.js monta o comando).
+"""
+import json
+import re
+import sys
+
+
+def main():
+    import numpy as np
+    import soundfile as sf
+    from kokoro import KPipeline
+
+    pipe = KPipeline(lang_code="p")
+    # uma passada curta aquece o modelo: a primeira frase de verdade já não paga a carga
+    try:
+        for _ in pipe("Oi.", voice="pf_dora"):
+            pass
+    except Exception:
+        pass
+    print(json.dumps({"pronto": True}), flush=True)
+    for linha in sys.stdin:
+        linha = linha.strip()
+        if not linha:
+            continue
+        pedido = {}
+        try:
+            pedido = json.loads(linha)
+            texto = re.sub(r"\s+", " ", str(pedido.get("texto") or "")).strip()
+            if not texto:
+                print(json.dumps({"id": pedido.get("id"), "ok": False, "error": "texto vazio"}), flush=True)
+                continue
+            partes = [np.asarray(a, dtype=np.float32) for _, _, a in pipe(texto, voice=pedido.get("voz") or "pf_dora")]
+            audio = np.concatenate(partes)
+            sf.write(str(pedido["saida"]), audio, 24000)
+            print(json.dumps({"id": pedido.get("id"), "ok": True, "arquivo": pedido["saida"], "segundos": round(len(audio) / 24000, 3)}), flush=True)
+        except Exception as e:
+            print(json.dumps({"id": pedido.get("id"), "ok": False, "error": str(e)[:300]}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

package/voz/primo_voz/transcrever.py

@@ -200,6 +200,31 @@ def main() -> int:
             return 1
         print(json.dumps({"ok": True, "palavras": ws}, ensure_ascii=False))
         return 0
+    if acao == "servir":
+        # `... servir [idioma]`: processo vivo do app (modo voz ao vivo). O modelo carrega UMA vez; cada linha de entrada é
+        # {"id":N,"arquivo":"x.wav"} e cada linha de saída é {"id":N,"ok":true,"texto":"..."}. Primeira linha: {"pronto":true}.
+        if not disponivel():
+            print(json.dumps({"ok": False, "error": "o faster-whisper não está instalado"}), flush=True)
+            return 1
+        idioma = sys.argv[2] if len(sys.argv) > 2 else "pt"
+        try:
+            carregar()
+        except Exception as e:
+            print(json.dumps({"ok": False, "error": str(e)}), flush=True)
+            return 1
+        print(json.dumps({"pronto": True, "modelo": MODELO}), flush=True)
+        for linha in sys.stdin:
+            linha = linha.strip()
+            if not linha:
+                continue
+            pedido = {}
+            try:
+                pedido = json.loads(linha)
+                texto = transcrever(Path(pedido["arquivo"]), idioma)
+                print(json.dumps({"id": pedido.get("id"), "ok": True, "texto": texto}, ensure_ascii=False), flush=True)
+            except Exception as e:
+                print(json.dumps({"id": pedido.get("id"), "ok": False, "error": str(e)}), flush=True)
+        return 0
     if acao == "arquivo":
         # `... arquivo <wav> [idioma]`: a fala de um arquivo vira texto (o app desktop grava no microfone e manda para cá).
         if not disponivel():