primocode 8.38.1 → 8.40.0

package/lib/referencia.js

@@ -56,7 +56,7 @@ function hostBloqueado(hostname) {
     return false; // hostname comum (DNS) — não dá pra saber o IP sem resolver
 }
 
-const TIMEOUT_MS = 12000;
+const TIMEOUT_MS = 8000;   // por página; os buscadores têm o PRAZO_BUSCADOR, menor
 const MAX_POR_FONTE = 4;
 const MAX_TEXTO = 4500;
 // Quanto HTML baixar antes de parar. Só os primeiros MAX_TEXTO caracteres de
@@ -95,7 +95,12 @@ function viaProxy(alvo, { timeout }) {
     });
 }
 
-function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
+// Bytes, não texto: a logo em PNG, a música em MP3. Mesmo caminho (proxy,
+// redirect, prazo duro, SSRF), corpo em Buffer e teto maior — um mp3 de três
+// minutos tem 5 MB, e 400 KB o cortariam no primeiro refrão.
+const LIMITE_BYTES = 40 * 1024 * 1024;
+
+function pegar(url, { timeout = TIMEOUT_MS, saltos = 0, binario = false } = {}) {
     return new Promise((resolve) => {
         let req;
         const alvo = (() => { try { return new URL(url); } catch { return null; } })();
@@ -128,6 +133,22 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
             })).catch(() => null)
             : Promise.resolve(opcoes);
 
+        // PRAZO DURO, do começo ao fim. O `timeout` do http é de OCIOSIDADE:
+        // um servidor que pinga um byte a cada segundo, ou um túnel que abre e
+        // trava no aperto de mão TLS, passava dele sem nunca disparar — medido:
+        // api.duckduckgo.com levava 11 s para devolver nada com timeout de 6 s.
+        // Aqui o relógio conta o tempo total; estourou, entrega o que veio.
+        let corpoParcial = '';
+        let encerrado = false;
+        const resolver = resolve;
+        const relogio = setTimeout(() => {
+            if (encerrado) return;
+            encerrado = true;
+            try { if (req) req.destroy(); } catch { /* já morto */ }
+            resolver(corpoParcial.length > 2000 ? corpoParcial : null);
+        }, timeout + 500);
+        resolve = (v) => { clearTimeout(relogio); if (!encerrado) { encerrado = true; resolver(v); } };
+
         abrir.then((cfg) => {
             if (!cfg) return resolve(null);
             try {
@@ -136,15 +157,29 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
                 if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                     res.resume();
                     const destino = new URL(res.headers.location, url).href;
-                    return pegar(destino, { timeout, saltos: saltos + 1 }).then(resolve);
+                    return pegar(destino, { timeout, saltos: saltos + 1, binario }).then(resolve);
                 }
                 if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+                if (binario) {
+                    // Bytes inteiros ou nada: meia logo e meio mp3 não servem.
+                    const pedacos = [];
+                    let total = 0;
+                    res.on('data', (c) => {
+                        total += c.length;
+                        if (total > LIMITE_BYTES) { res.destroy(); return resolve(null); }
+                        pedacos.push(c);
+                    });
+                    res.on('end', () => resolve(Buffer.concat(pedacos)));
+                    res.on('error', () => resolve(null));
+                    return;
+                }
                 let corpo = '';
                 let pronto = false;
                 const entregar = (valor) => { if (!pronto) { pronto = true; resolve(valor); } };
                 res.setEncoding('utf8');
                 res.on('data', (c) => {
                     corpo += c;
+                    corpoParcial = corpo;
                     // Página grande: PARA de baixar e entrega o que já veio.
                     //
                     // Antes isto era `req.destroy()` sem entregar nada, e o
@@ -338,7 +373,7 @@ async function chutesVivos(chutes, limite = 2) {
     // centenas de KB. Com 6 s o site CERTO chegava atrasado, era descartado
     // como morto, e a pesquisa falhava com o site no ar — medido.
     const respostas = await Promise.all(chutes.slice(0, 12).map(async (c) => {
-        const html = await pegar(c.url, { timeout: 12000 });
+        const html = await pegar(c.url, { timeout: 8000 });
         return html && html.length > 500 ? { cand: c, html } : null;
     }));
     const vivos = [];
@@ -373,9 +408,15 @@ function limparLinks(pares, limite) {
     return bons;
 }
 
+// Prazo de UM buscador. Eles rodam em paralelo (ver `buscar`), então este é
+// o teto da busca inteira — não a soma. Medido: o DuckDuckGo estava levando
+// 11 s para devolver NADA, e a pesquisa esperava por ele antes de tentar o
+// Bing, que respondia em meio segundo.
+const PRAZO_BUSCADOR = 6000;
+
 /** DuckDuckGo (HTML). O destino vem embrulhado em /l/?uddg=<url>. */
 async function buscarDDG(consulta, limite) {
-    const html = await pegar(`https://duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`);
+    const html = await pegar(`https://duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`, { timeout: PRAZO_BUSCADOR });
     if (!html) return [];
     const pares = [];
     const re = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
@@ -442,29 +483,73 @@ async function buscarRespostaDDG(consulta, limite) {
     return limparLinks(achados, limite);
 }
 
-/** Bing (HTML) — a reserva quando o DDG não responde. */
+/**
+ * O destino de um link do Bing.
+ *
+ * O Bing embrulha TODO resultado em `bing.com/ck/a?…&u=a1<base64url>`: o
+ * `a1` é prefixo, o resto é a URL em base64 (alfabeto de URL, sem "="). O
+ * parser antigo lia o `<cite>` — que mostra a URL com " › " no lugar das
+ * barras e reticências no meio — e por isso casava zero resultados numa
+ * página com dez. Medido no IP deste servidor: 117 KB de HTML, dez
+ * resultados, nenhum aproveitado. O buscador respondia; nós é que não líamos.
+ */
+function destinoBing(href) {
+    const h = String(href || '').replace(/&amp;/g, '&');
+    const m = /[?&]u=a1([A-Za-z0-9_-]+)/.exec(h);
+    if (!m) return /^https?:\/\//i.test(h) && !/bing\.com\//i.test(h) ? h : null;
+    try {
+        const b64 = m[1].replace(/-/g, '+').replace(/_/g, '/');
+        const url = Buffer.from(b64 + '='.repeat((4 - (b64.length % 4)) % 4), 'base64').toString('utf8');
+        return /^https?:\/\//i.test(url) ? url : null;    // "/images/search?…" é do próprio Bing
+    } catch { return null; }
+}
+
+/** Bing (HTML). Responde rápido e sem bloquear onde o DDG cala. */
 async function buscarBing(consulta, limite) {
-    const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
+    const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`, { timeout: PRAZO_BUSCADOR });
     if (!html) return [];
     const pares = [];
-    // O Bing largou o <h2><a href> e hoje mostra a URL num <cite>, com " › "
-    // no lugar da barra. O parser antigo casava ZERO resultados numa página
-    // que trazia dez — e a pesquisa caía na Wikipédia, que era o lixo.
-    const cites = html.match(/<cite[^>]*>[\s\S]{0,200}?<\/cite>/gi) || [];
-    for (const bruto of cites) {
-        const mostrado = textoDe(bruto);
-        if (!/^https?:\/\//i.test(mostrado) || /[…]/.test(mostrado)) continue;
-        pares.push({ titulo: mostrado.replace(/\s*›\s*/g, ' / '), url: mostrado.replace(/\s*›\s*/g, '/') });
+    const re = /<h2[^>]*>\s*<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    while ((m = re.exec(html))) {
+        const url = destinoBing(m[1]);
+        if (url) pares.push({ titulo: textoDe(m[2]), url });
     }
-    const re = /<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    return limparLinks(pares, limite);
+}
+
+/**
+ * Yahoo (HTML). Também embrulha: `r.search.yahoo.com/…/RU=<url codificada>/RK=…`.
+ * É a segunda porta que responde onde o DDG não responde — e os índices dos
+ * dois (Bing e Yahoo) são parecidos, então os dois juntos confirmam um ao
+ * outro mais do que ampliam.
+ */
+function destinoYahoo(href) {
+    const h = String(href || '').replace(/&amp;/g, '&');
+    const m = /\/RU=([^/]+)/.exec(h);
+    if (!m) return /^https?:\/\//i.test(h) && !/yahoo\.com\//i.test(h) ? h : null;
+    try {
+        const url = decodeURIComponent(m[1]);
+        return /^https?:\/\//i.test(url) && !/yahoo\.com\//i.test(url) ? url : null;
+    } catch { return null; }
+}
+
+async function buscarYahoo(consulta, limite) {
+    const html = await pegar(`https://search.yahoo.com/search?p=${encodeURIComponent(consulta)}`, { timeout: PRAZO_BUSCADOR });
+    if (!html) return [];
+    const pares = [];
+    const re = /<h3[^>]*class="[^"]*\btitle\b[^"]*"[^>]*>\s*<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
     let m;
-    while ((m = re.exec(html))) pares.push({ titulo: textoDe(m[2]), url: m[1] });
+    while ((m = re.exec(html))) {
+        const url = destinoYahoo(m[1]);
+        if (url) pares.push({ titulo: textoDe(m[2]), url });
+    }
     return limparLinks(pares, limite);
 }
 
 /** SearXNG público, em JSON — a terceira porta. */
 async function buscarSearx(consulta, limite) {
-    const corpo = await pegar(`https://searx.be/search?q=${encodeURIComponent(consulta)}&format=json`);
+    const corpo = await pegar(`https://searx.be/search?q=${encodeURIComponent(consulta)}&format=json`, { timeout: PRAZO_BUSCADOR });
     if (!corpo) return [];
     try {
         const j = JSON.parse(corpo);
@@ -473,29 +558,33 @@ async function buscarSearx(consulta, limite) {
 }
 
 /**
- * Busca na web. Tenta as portas em ordem e para na primeira que responder —
- * um buscador fora do ar (ou bloqueado pela rede) não pode desligar a
- * pesquisa inteira. Sem chave de API em nenhuma delas.
+ * Busca na web — TODAS as portas de uma vez, e fica com o que voltar.
+ *
+ * Em fila, o buscador que não responde segura os outros: o DDG gastava 11 s
+ * para calar, e só então o Bing era tentado. Em paralelo, a pesquisa leva o
+ * tempo do MAIS RÁPIDO que respondeu com algo (e no máximo PRAZO_BUSCADOR).
+ * A ordem da lista é a ordem de confiança na hora de juntar: o que vem
+ * primeiro entra primeiro. Sem chave de API em nenhuma delas.
  */
 async function buscar(consulta, limite = MAX_POR_FONTE) {
-    // Ordem deliberada: primeiro os buscadores raspados (dão os links mais
-    // frescos, quando respondem), depois as APIs que NUNCA bloqueiam. Antes a
-    // fila acabava no Searx e, com os três calados, a pesquisa inteira voltava
-    // vazia — mesmo havendo resposta boa na Wikipédia.
-    const portas = [buscarDDG, buscarBing, buscarSearx, buscarRespostaDDG, buscarWikipedia];
+    const portas = [buscarBing, buscarYahoo, buscarDDG, buscarSearx, buscarRespostaDDG, buscarWikipedia];
+    const respostas = await Promise.all(portas.map((p) => p(consulta, limite).catch(() => [])));
     const juntos = [];
-    for (const porta of portas) {
-        try {
-            const achados = await porta(consulta, limite);
-            for (const a of achados) {
-                if (!juntos.some((j) => j.url === a.url)) juntos.push(a);
-            }
-            // Os raspados, quando respondem, já bastam. As APIs entram para
-            // completar quando eles vieram vazios.
-            if (juntos.length >= limite) break;
-        } catch {}
+    const dominios = new Map();
+    for (const achados of respostas) {
+        for (const a of achados) {
+            if (juntos.some((j) => j.url === a.url)) continue;
+            // No máximo dois links do mesmo domínio: uma página de resultados
+            // dominada por um site só (a Wikipédia, o próprio produto) não é
+            // variedade de fonte.
+            const dom = (a.url.match(/^https?:\/\/(?:www\.)?([^/]+)/i) || [])[1] || a.url;
+            const n = dominios.get(dom) || 0;
+            if (n >= 2) continue;
+            dominios.set(dom, n + 1);
+            juntos.push(a);
+        }
     }
-    return juntos.slice(0, limite);
+    return juntos.slice(0, limite * 2);
 }
 
 /** Respostas do StackOverflow — a API pública, sem chave. */
@@ -515,24 +604,61 @@ async function stackoverflow(consulta, limite = 3) {
     } catch { return []; }
 }
 
-// Última porta: a documentação oficial dos assuntos mais comuns, direto. Não
-// depende de buscador nenhum — é o que salva a pesquisa em rede corporativa
-// que bloqueia mecanismo de busca mas libera site de documentação.
+/**
+ * A documentação oficial, direto — não depende de buscador nenhum, e é o que
+ * salva a pesquisa em rede corporativa que bloqueia buscador e libera site de
+ * documentação.
+ *
+ * A MDN entra pela API dela, não pela página de busca: a página é uma casca
+ * que carrega os resultados por JavaScript, e o que chegava aqui eram 226
+ * caracteres de menu. A pesquisa dizia "1 fonte lida" e o modelo recebia
+ * nada — foi assim que "liquid glass css" voltou de mãos vazias com a
+ * resposta certa (backdrop-filter) a uma chamada de distância. A API devolve
+ * os artigos com resumo, e o artigo é a melhor fonte que existe sobre CSS.
+ * O mesmo vale para o python.org: a busca lá é JavaScript, e o índice dos
+ * módulos é o que se lê.
+ */
+// Palavras que toda consulta técnica carrega e que não apontam artigo nenhum.
+// "effect" casava vector-effect para "liquid glass css effect" — e o modelo
+// recebia a doc de SVG como referência de vidro.
+const TECNICAS_GENERICAS = new Set(['css', 'html', 'javascript', 'js', 'effect', 'efeito', 'effects', 'como', 'fazer',
+    'how', 'make', 'create', 'criar', 'tutorial', 'example', 'exemplo', 'code', 'codigo', 'with', 'using', 'web',
+    'style', 'estilo', 'property', 'propriedade', 'usar', 'use', 'best', 'melhor', 'simple', 'simples']);
+
+async function buscarMDN(consulta, limite = 3) {
+    const palavras = palavrasDaConsulta(consulta).filter((p) => !TECNICAS_GENERICAS.has(p));
+    if (!palavras.length) return [];
+    const bruto = await pegar(`https://developer.mozilla.org/api/v1/search?q=${encodeURIComponent(palavras.join(' '))}&locale=en-US`, { timeout: PRAZO_BUSCADOR });
+    if (!bruto) return [];
+    try {
+        const j = JSON.parse(bruto);
+        return (j.documents || [])
+            // O índice da MDN casa por palavra, e "effect" casa vector-effect.
+            // Só entra o artigo cujo título ou caminho traz uma palavra que
+            // é DO ASSUNTO — as genéricas já saíram acima.
+            .filter((d) => {
+                const alvo = `${d.title} ${d.slug}`.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+                return palavras.some((p) => alvo.includes(p));
+            })
+            .slice(0, limite).map((d) => ({
+                titulo: d.title,
+                url: 'https://developer.mozilla.org' + d.mdn_url,
+                nota: 'MDN' + (d.summary ? ' — ' + String(d.summary).slice(0, 160) : ''),
+            }));
+    } catch { return []; }
+}
+
 const DOCS = [
-    [/\b(js|javascript|array|string|promise|fetch|dom|css|html|regex)\b/i,
-        (q) => `https://developer.mozilla.org/en-US/search?q=${encodeURIComponent(q)}`],
-    [/\b(react|jsx|hook|usestate|useeffect)\b/i, () => 'https://react.dev/reference/react'],
-    [/\b(node|npm|express|fs|require)\b/i, () => 'https://nodejs.org/docs/latest/api/'],
-    [/\b(python|django|flask|pandas)\b/i,
-        (q) => `https://docs.python.org/3/search.html?q=${encodeURIComponent(q)}`],
+    [/\b(js|javascript|array|string|promise|fetch|dom|css|html|regex|svg|canvas|webgl|animation|keyframes|backdrop|filter|grid|flex)\b/i, buscarMDN],
+    [/\b(react|jsx|hook|usestate|useeffect)\b/i, async () => [{ titulo: 'React — referência', url: 'https://react.dev/reference/react', nota: 'documentação oficial' }]],
+    [/\b(node|npm|express|fs|require)\b/i, async () => [{ titulo: 'Node.js — API', url: 'https://nodejs.org/docs/latest/api/', nota: 'documentação oficial' }]],
+    [/\b(python|django|flask|pandas)\b/i, async () => [{ titulo: 'Python — índice dos módulos', url: 'https://docs.python.org/3/py-modindex.html', nota: 'documentação oficial' }]],
 ];
 
-function docsConhecidas(consulta) {
-    const achados = [];
-    for (const [re, url] of DOCS) {
-        if (re.test(consulta)) achados.push({ titulo: 'documentação oficial', url: url(consulta) });
-    }
-    return achados;
+async function docsConhecidas(consulta) {
+    const casam = DOCS.filter(([re]) => re.test(consulta));
+    const listas = await Promise.all(casam.map(([, f]) => f(consulta).catch(() => [])));
+    return listas.flat();
 }
 
 /**
@@ -543,9 +669,15 @@ async function pesquisar({ consulta, paginas = 3 }) {
     const termo = String(consulta || '').trim();
     if (!termo) return { ok: false, error: 'diga o que pesquisar' };
 
-    const [web, so] = await Promise.all([
+    // Tudo de uma vez: os buscadores, o StackOverflow, a documentação e a
+    // sonda dos sites prováveis da empresa. A pesquisa leva o tempo do mais
+    // lento que RESPONDEU, não a soma de todos.
+    const palpites = sitesProvaveis(termo);
+    const [web, so, docs, sondados] = await Promise.all([
         buscar(termo, MAX_POR_FONTE),
         stackoverflow(termo, 2),
+        docsConhecidas(termo),
+        chutesVivos(palpites),
     ]);
 
     // A documentação oficial entra SEMPRE na fila, não só quando as outras
@@ -559,20 +691,28 @@ async function pesquisar({ consulta, paginas = 3 }) {
     // respondem ocupam vaga. São dez palpites (5 TLDs x com/sem www) e a
     // maioria não existe — enfileirar todos expulsaria os resultados reais
     // do buscador. A sonda roda em paralelo e o HTML já volta aproveitado.
-    const palpites = sitesProvaveis(termo);
-    const { vivos, html: htmlChutes } = await chutesVivos(palpites);
+    const { vivos, html: htmlChutes } = sondados;
     // A sonda ORDENA, não faz porteiro. Ela é uma corrida contra o relógio
     // contra home pesada e rede lenta, e perdê-la não pode significar perder
     // o site certo: quando nada responde a tempo, os primeiros palpites vão
     // para a fila mesmo assim e o laço de leitura tenta de novo, sem pressa.
     const chutes = vivos.length ? vivos : palpites.slice(0, 3);
     const palavras = palavrasDaConsulta(termo);
-    const brutos = [...chutes, ...web, ...so, ...docsConhecidas(termo)];
+    // A documentação oficial vai NA FRENTE dos links de buscador: quando a
+    // consulta é técnica, o artigo da MDN vale mais que o blog que o Bing
+    // pôs em primeiro.
+    const brutos = [...chutes, ...docs, ...web, ...so];
 
     // Fora o que não é sobre o assunto. Sem isto o modelo recebia "Milan" e
     // "History of autism" para uma pesquisa sobre uma empresa, e escrevia o
     // vídeo com aquilo.
-    const filtrados = brutos.filter((cand) => cand.nota === 'site provável da empresa' || relevante(cand, palavras));
+    // A documentação oficial passa pelo nome: "backdrop-filter CSS property"
+    // não repete as palavras de "liquid glass css effect", e mesmo assim é a
+    // resposta. Quem a escolheu foi o índice da MDN, que entende sinônimo —
+    // o filtro de palavras é para link de buscador, que devolve página
+    // aleatória quando não conhece o assunto.
+    const filtrados = brutos.filter((cand) => cand.nota === 'site provável da empresa'
+        || /^(MDN|documentação oficial)/.test(String(cand.nota || '')) || relevante(cand, palavras));
     const candidatos = filtrados.slice(0, Math.max(2, Math.min(10, paginas + 6)));
     const descartados = brutos.length - filtrados.length;
     if (!candidatos.length) {
@@ -602,14 +742,20 @@ async function pesquisar({ consulta, paginas = 3 }) {
     // Os chutes de domínio ficam de lado até o fim: só então dá para saber
     // qual deles fala mais do assunto.
     const chutesLidos = [];
-    for (const cand of candidatos) {
+    // As páginas abrem JUNTAS, não uma depois da outra: dez candidatos a 2 s
+    // cada eram 20 s de espera antes de ler a primeira linha. Quem não abriu
+    // vira null e é pulado na ordem — a ordem de confiança continua valendo.
+    const paginasAbertas = await Promise.all(candidatos.map((cand) =>
+        htmlChutes.has(cand.url) ? Promise.resolve(htmlChutes.get(cand.url)) : pegar(cand.url)));
+    for (let ic = 0; ic < candidatos.length; ic++) {
+        const cand = candidatos[ic];
         if (lidas.length >= paginas) break;
-        // A sonda já baixou o HTML dos chutes: reaproveita em vez de pedir
-        // a mesma página duas vezes.
-        const html = htmlChutes.get(cand.url) || await pegar(cand.url);
+        const html = paginasAbertas[ic];
         if (!html) continue;
         const texto = textoDe(html);
-        if (texto.length < 200) continue;
+        // 400, não 200: uma casca de página que carrega tudo por JavaScript
+        // deixa 200-300 caracteres de menu, e isso passava como "fonte lida".
+        if (texto.length < 400) continue;
         if (pareceCodigo(texto)) continue;
         // O chute de domínio precisa PROVAR que acertou. "Paris Group" tem
         // parisgroup.com (um grupo de varejo no exterior) e parisgroup.ai (a
@@ -675,4 +821,5 @@ async function pesquisar({ consulta, paginas = 3 }) {
 }
 
 module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG, pegar,
-    relevante, quantoBate, palavrasDaConsulta, sitesProvaveis, pareceCodigo };
+    relevante, quantoBate, palavrasDaConsulta, sitesProvaveis, chutesVivos, pareceCodigo,
+    destinoBing, destinoYahoo, buscarBing, buscarYahoo, buscarMDN, docsConhecidas, PRAZO_BUSCADOR };