primocode 1.0.0

package/lib/act.js

@@ -0,0 +1,495 @@
+// Modo Conecta Primo AI — faz tudo sozinho: código, arquivos, terminal, navegador
+
+'use strict';
+
+const path = require('path');
+const { c, actionHeader, toolLine, Spinner } = require('./ui');
+const tools = require('./tools');
+const api = require('./api');
+
+const MAX_ITERATIONS = 15;
+
+function fmtArgs(name, args) {
+    if (!args) return '';
+    switch (name) {
+        case 'read_file':          return args.path || '';
+        case 'write_file':         return `${args.path || ''} · ${(args.content || '').length} chars`;
+        case 'list_dir':           return args.path || '.';
+        case 'run_shell':          return args.command || '';
+        case 'run_in_new_terminal':return `${args.command || ''}${args.cwd ? ' @ ' + args.cwd : ''}`;
+        case 'open_in_browser':    return args.target || '';
+        case 'browser_open':       return args.url || '';
+        case 'browser_navigate':   return args.url || '';
+        case 'browser_click':      return args.selector || args.text || (args.x != null ? `${args.x},${args.y}` : '');
+        case 'browser_type':       return `${args.selector ? args.selector + ' · ' : ''}${(args.text || '').length} chars`;
+        case 'browser_key':        return args.key || '';
+        case 'browser_wait_for':   return args.selector || '';
+        case 'browser_wait':       return `${args.ms || 1000}ms`;
+        case 'browser_screenshot': return args.path || '(auto)';
+        case 'browser_eval':       return (args.js || '').slice(0, 60);
+        case 'browser_scroll':     return `dy=${args.dy || 400}`;
+        case 'browser_url':        return '';
+        case 'finish':             return args.summary || '';
+        default: return JSON.stringify(args).slice(0, 80);
+    }
+}
+
+// Nomes simples das ações
+const NICE = {
+    read_file: 'Read', write_file: 'Write', list_dir: 'List',
+    run_shell: 'Bash', run_in_new_terminal: 'Terminal', open_in_browser: 'Open',
+    browser_open: 'Browser', browser_navigate: 'Navigate', browser_click: 'Click',
+    browser_clickText: 'ClickText', browser_type: 'Type', browser_key: 'Key',
+    browser_wait_for: 'Wait', browser_wait: 'Wait', browser_screenshot: 'Screenshot',
+    browser_eval: 'Eval', browser_scroll: 'Scroll', browser_url: 'URL', finish: 'Finish',
+};
+
+function makeLogger() {
+    return {
+        event(kind, arg, result) {
+            if (kind === 'run_shell') return;
+            if (kind === 'run_shell_done') {
+                if (result) {
+                    const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed ? ' timeout' : ''}`);
+                    process.stdout.write('\n' + s + '\n');
+                }
+                return;
+            }
+            const prefix = c.muted('  ⎿ ');
+            if (kind === 'write_file' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
+                return;
+            }
+            if (kind === 'read_file' && result && result.ok) {
+                console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
+                return;
+            }
+            if (kind === 'list_dir' && result && result.ok) {
+                const lines = result.tree.split('\n').slice(0, 8);
+                for (const l of lines) console.log(prefix + c.muted(l));
+                const total = result.tree.split('\n').length;
+                if (total > 8) console.log(prefix + c.muted(`… +${total - 8}`));
+                return;
+            }
+            if (kind === 'open_in_browser' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.opener || 'browser'}`));
+                return;
+            }
+            if (kind === 'run_in_new_terminal' && result && result.ok) {
+                console.log(prefix + c.muted(`${result.opener}`));
+                return;
+            }
+            if (kind === 'finish') {
+                console.log(prefix + c.muted(arg || 'ok'));
+                return;
+            }
+            if (result && result.ok === false) {
+                console.log(prefix + c.err(result.error || 'failed'));
+            }
+        },
+    };
+}
+
+/**
+ * Executa uma tarefa em modo Act (agente autônomo com tools).
+ * @param {string} userPrompt - texto do usuário
+ * @param {object} opts - { server, model, history: [{role,content}, ...] }
+ * @returns {Promise<{userMessage, assistantMessage}>}  para o caller atualizar seu histórico
+ */
+async function runAct(userPrompt, opts) {
+    const { server, model, history: chatHistory = [] } = opts;
+
+    // Injeta contexto do CWD e inclui histórico curto de conversa
+    const cwd = process.cwd();
+    const cwdBase = path.basename(cwd);
+    const enriched = `[contexto: diretório atual = ${cwd} (basename: '${cwdBase}')]\n\n${userPrompt}`;
+
+    // Estado do loop
+    // Começamos com as mensagens do chat (para memória) + o novo user prompt.
+    let messages = [];
+    if (Array.isArray(chatHistory) && chatHistory.length) {
+        // Só passamos user/assistant sem tool_calls (o histórico de tool calls foi episódico).
+        for (const m of chatHistory) {
+            if (m && (m.role === 'user' || m.role === 'assistant') && m.content) {
+                messages.push({ role: m.role, content: m.content });
+            }
+        }
+    }
+
+    let promptForCall = enriched;
+    let toolResults = null;
+    let finished = false;
+    const log = makeLogger();
+    const recentCalls = [];
+    let finalAssistantText = '';
+    let sp = null;
+    let planCache = '';    // cache do plano do Planner entre turnos
+    let planShown = false; // evita mostrar plano múltiplas vezes
+    const filesWritten = new Set(); // arquivos criados/modificados pelo Construtor 1 (para refino)
+    const deferredOpens = [];       // open_in_browser adiados até depois do refino
+
+    for (let iter = 1; iter <= MAX_ITERATIONS && !finished; iter++) {
+        let assistantContent = '';
+        let assistantMessage = null;
+        let toolCalls = [];
+        let serverErr = null;
+        let hasToolCalls = false;
+        let streamingStarted = false;
+        let printedUpTo = 0;         // quantos chars de assistantContent já foram impressos
+        let suppressRest = false;    // uma vez detectado marker, para de imprimir
+        let retryNeeded = false;     // server pedidu retry (ex: finish rejeitado)
+        let rejectedNote = null;     // motivo da rejeição, injetado como tool_result no próximo turno
+        let subagentsPayload = null; // resultado de spawn_parallel (injetado como tool_result)
+        let subagentsToolCallId = null;
+        let subagentsTotal = 0;
+        let subagentsDone = 0;
+
+        // Spinner enquanto aguarda primeiro byte
+        sp = new Spinner('Pensando').start();
+
+        try {
+            await api.requestStream(server, '/api/act/stream', {
+                prompt: promptForCall,
+                history: messages,
+                tool_results: toolResults,
+                model,
+                plan_cache: planCache,
+            }, (evt) => {
+                if (evt.phase === 'inspiring') {
+                    if (sp) sp.stop();
+                    sp = new Spinner('Buscando referências').start();
+                }
+                if (evt.inspiration_urls && Array.isArray(evt.inspiration_urls) && evt.inspiration_urls.length > 0) {
+                    if (sp) { sp.stop(); sp = null; }
+                    console.log('\n' + c.muted('◆ Inspirando-se em:'));
+                    for (const u of evt.inspiration_urls) console.log(c.muted('  · ') + c.accent(u));
+                }
+                if (evt.phase === 'planning' && !planShown) {
+                    if (sp) sp.stop();
+                    sp = new Spinner('Pensando').start();
+                }
+                if (evt.plan) {
+                    planCache = evt.plan;
+                    if (sp) { sp.stop(); sp = null; }
+                    planShown = true;
+                    sp = new Spinner('Executando').start();
+                }
+                if (evt.subagents_spawning) {
+                    subagentsTotal = evt.subagents_spawning;
+                    if (sp) sp.stop();
+                    console.log('\n' + c.muted(`◆ Spawn de ${subagentsTotal} subagentes em paralelo`));
+                    sp = new Spinner(`Subagentes 0/${subagentsTotal}`).start();
+                }
+                if (evt.subagent_done) {
+                    subagentsDone++;
+                    const d = evt.subagent_done;
+                    if (sp) { sp.stop(); sp = null; }
+                    const status = d.ok ? c.ok('✓') : c.err('✗');
+                    console.log(`  ${status} ${c.muted(d.title)} ${c.muted('· ' + (d.bytes || 0) + ' bytes')}`);
+                    if (subagentsDone < subagentsTotal) sp = new Spinner(`Subagentes ${subagentsDone}/${subagentsTotal}`).start();
+                }
+                if (evt.subagents_result) {
+                    subagentsPayload = evt.subagents_result;
+                    subagentsToolCallId = evt.tool_call_id;
+                    if (sp) { sp.stop(); sp = null; }
+                }
+                if (evt.erro) { serverErr = evt.erro; return; }
+                if (evt.delta) {
+                    if (!streamingStarted) {
+                        sp.stop();
+                        process.stdout.write('\n');
+                        streamingStarted = true;
+                    }
+                    assistantContent += evt.delta;
+
+                    if (suppressRest) return;
+
+                    // Se aparece começo de marker suspeito, marca e para de imprimir daqui em diante.
+                    // Também "rebobina" cortando o que já foi acumulado até antes do marker
+                    // (não conseguimos apagar do terminal, mas o texto final ficará limpo).
+                    const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
+                    const m = assistantContent.match(leakRe);
+                    if (m && m.index !== undefined) {
+                        const safeEnd = m.index;
+                        if (safeEnd > printedUpTo) {
+                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
+                            printedUpTo = safeEnd;
+                        }
+                        suppressRest = true;
+                        return;
+                    }
+
+                    // Imprime até len-2 para dar margem se um marker começar a formar
+                    const target = Math.max(printedUpTo, assistantContent.length - 2);
+                    if (target > printedUpTo) {
+                        process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
+                        printedUpTo = target;
+                    }
+                }
+                if (evt.tool_call) toolCalls.push(evt.tool_call);
+                if (evt.assistant_message) assistantMessage = evt.assistant_message;
+                if (evt.tool_rejected) rejectedNote = evt.tool_rejected;
+                if (evt.retry_needed) retryNeeded = true;
+                if (evt.done) hasToolCalls = !!evt.has_tool_calls;
+                if (evt.instability) { serverErr = 'servidor com rate-limit; tente novamente em alguns minutos'; return; }
+            });
+        } catch (e) {
+            if (sp) sp.stop();
+            console.log(c.err(`\nerro: ${e.message}`));
+            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${e.message}]` } };
+        }
+
+        if (sp && !streamingStarted) sp.stop();
+
+        // Flush do buffer de 2 chars retido para evitar corte de markers
+        if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
+            process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
+            printedUpTo = assistantContent.length;
+        }
+
+        if (serverErr) {
+            console.log(c.err(`\nerro: ${serverErr}`));
+            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${serverErr}]` } };
+        }
+
+        if (streamingStarted) process.stdout.write('\n');
+
+        // Atualiza messages internas do loop (com tool_calls, para o modelo saber o que pediu)
+        if (assistantMessage) messages.push(assistantMessage);
+        else messages.push({ role: 'assistant', content: assistantContent });
+
+        // No primeiro turno, inserimos o user antes do assistant (foi só passado como prompt)
+        if (iter === 1) {
+            const last = messages.pop();
+            messages.push({ role: 'user', content: enriched });
+            messages.push(last);
+        }
+
+        promptForCall = null;
+
+        if (assistantContent) {
+            let cleaned = assistantContent
+                .replace(/<\|[\s\S]*$/g, '')
+                .replace(/【[\s\S]*$/g, '')
+                .replace(/\n\s*\{\s*"(name|type|summary|arguments|command|path)"[\s\S]*$/, '')
+                .replace(/^\s*\{\s*"(name|type|summary|arguments)"[\s\S]*$/, '')
+                // Corta chamadas de função vazadas em texto
+                .replace(/\b(finish|write_file|read_file|list_dir|run_shell|run_in_new_terminal|open_in_browser|browser_\w+)\s*\([\s\S]*$/g, '')
+                .trim();
+            if (cleaned) finalAssistantText = cleaned;
+        }
+
+        // Subagentes rodaram — injeta resultado como tool_result e segue loop
+        if (subagentsPayload && subagentsToolCallId) {
+            toolResults = [{ tool_call_id: subagentsToolCallId, result: JSON.stringify(subagentsPayload) }];
+            promptForCall = null;
+            continue;
+        }
+
+        // Server pediu retry (ex: finish sem trabalho no primeiro turno)
+        if (retryNeeded && rejectedNote) {
+            // Injeta pseudo tool_result educativo pro próximo turno
+            const rejectedId = assistantMessage?.tool_calls?.[0]?.id;
+            if (rejectedId) {
+                toolResults = [{ tool_call_id: rejectedId, result: JSON.stringify({ ok: false, error: rejectedNote.reason }) }];
+            }
+            // Novo prompt reforçando a ordem
+            promptForCall = `[sistema] Seu último ${rejectedNote.name}() foi rejeitado: ${rejectedNote.reason}\n\nExecute o pedido original agora, usando as ferramentas corretas antes de qualquer finish.`;
+            continue;
+        }
+
+        if (!hasToolCalls || toolCalls.length === 0) {
+            finished = true;
+            break;
+        }
+
+        // Executa cada tool
+        const results = [];
+        for (const tc of toolCalls) {
+            const name = tc.name;
+            const args = tc.arguments || {};
+            const nice = NICE[name] || name;
+            const detail = fmtArgs(name, args);
+            console.log('\n' + toolLine(nice, detail));
+
+            let res;
+            // Interceptação: se o Construtor 1 quer abrir arquivo E há refino planejado,
+            // adia a abertura pra DEPOIS do refino (não mostra ao usuário versão bugada).
+            // Só adiamos se já houver pelo menos 1 arquivo escrito (senão não faz sentido refinar).
+            const shouldDeferOpen = (name === 'open_in_browser' && args.target && filesWritten.size > 0);
+            if (shouldDeferOpen) {
+                deferredOpens.push(args.target);
+                res = { ok: true, text_for_model: JSON.stringify({ ok: true, deferred: true, note: 'abertura adiada para depois do refino' }) };
+                console.log(c.muted('  ⎿ adiado até depois do refino'));
+            } else {
+                try {
+                    res = await tools.executeTool(name, args, log);
+                } catch (e) {
+                    res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) };
+                    console.log(c.err(`  exception: ${e.message}`));
+                }
+            }
+            results.push({ tool_call_id: tc.id, result: res.text_for_model });
+
+            // Rastreia arquivos escritos para depois passar ao Construtor 2 (refino)
+            if (name === 'write_file' && args.path) {
+                try { filesWritten.add(String(args.path)); } catch { /* noop */ }
+            }
+
+            if (res.finish) finished = true;
+
+            const sig = name + '|' + JSON.stringify(args);
+            recentCalls.push(sig);
+            if (recentCalls.length > 4) recentCalls.shift();
+            if (recentCalls.filter(s => s === sig).length >= 3) {
+                console.log('\n' + c.warn('loop detectado — encerrando.'));
+                finished = true;
+                break;
+            }
+        }
+
+        toolResults = results;
+        if (finished) break;
+    }
+
+    if (!finished) console.log('\n' + c.warn(`limite de ${MAX_ITERATIONS} iterações atingido.`));
+
+    // ═══ FASE C — Refino (Construtor 2) ═══
+    // Só refina se o Construtor 1 realmente criou/modificou arquivos.
+    // Não refina para saudações/perguntas conceituais.
+    if (filesWritten.size > 0) {
+        const refineFiles = Array.from(filesWritten).slice(0, 8); // cap defensivo
+        console.log('\n' + c.muted('◆ Refinando (Construtor 2)'));
+        let refineSp = new Spinner('Melhorando').start();
+        let refineIter = 0;
+        let refineDone = false;
+        let refineToolResults = null;
+        const REFINE_MAX = 6;
+        // Histórico ISOLADO do refino — nunca inclui o histórico do executor
+        // (isso quebra o Groq porque as tool_calls antigas não têm tool_results correspondentes).
+        const refineMessages = [];
+
+        while (!refineDone && refineIter < REFINE_MAX) {
+            refineIter++;
+            let assistantMessage = null;
+            let toolCalls = [];
+            let serverErr = null;
+            let hasToolCalls = false;
+            let streamingStarted = false;
+            let printedUpTo = 0;
+            let suppressRest = false;
+            let assistantContent = '';
+
+            try {
+                await api.requestStream(server, '/api/act/stream', {
+                    refine: true,
+                    refine_files: refineFiles,
+                    refine_original_prompt: userPrompt,
+                    refine_history: refineMessages,
+                    tool_results: refineToolResults,
+                    model,
+                }, (evt) => {
+                    if (evt.erro) { serverErr = evt.erro; return; }
+                    if (evt.delta) {
+                        if (!streamingStarted) {
+                            if (refineSp) { refineSp.stop(); refineSp = null; }
+                            process.stdout.write('\n');
+                            streamingStarted = true;
+                        }
+                        assistantContent += evt.delta;
+                        if (suppressRest) return;
+                        const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
+                        const mm = assistantContent.match(leakRe);
+                        if (mm && mm.index !== undefined) {
+                            const safeEnd = mm.index;
+                            if (safeEnd > printedUpTo) {
+                                process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
+                                printedUpTo = safeEnd;
+                            }
+                            suppressRest = true;
+                            return;
+                        }
+                        const target = Math.max(printedUpTo, assistantContent.length - 2);
+                        if (target > printedUpTo) {
+                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
+                            printedUpTo = target;
+                        }
+                    }
+                    if (evt.tool_call) toolCalls.push(evt.tool_call);
+                    if (evt.assistant_message) assistantMessage = evt.assistant_message;
+                    if (evt.done) hasToolCalls = !!evt.has_tool_calls;
+                    if (evt.instability) { serverErr = 'refino indisponível (rate-limit)'; return; }
+                    if (evt.refine_skipped) { refineDone = true; return; }
+                });
+            } catch (e) {
+                if (refineSp) refineSp.stop();
+                console.log(c.warn(`\n(refino pulado: ${e.message})`));
+                break;
+            }
+
+            if (refineSp && !streamingStarted) refineSp.stop();
+            if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
+                process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
+            }
+            if (streamingStarted) process.stdout.write('\n');
+
+            if (serverErr) { console.log(c.warn(`\n(refino falhou: ${serverErr})`)); break; }
+
+            // Guarda o assistant_message NO HISTÓRICO ISOLADO do refino (não no messages global)
+            if (assistantMessage) refineMessages.push(assistantMessage);
+            if (!hasToolCalls || toolCalls.length === 0) { refineDone = true; break; }
+
+            const results = [];
+            for (const tc of toolCalls) {
+                const name = tc.name;
+                const args = tc.arguments || {};
+                const nice = NICE[name] || name;
+                const detail = fmtArgs(name, args);
+                console.log('\n' + toolLine(nice, detail));
+                let res;
+                try { res = await tools.executeTool(name, args, log); }
+                catch (e) { res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) }; console.log(c.err(`  exception: ${e.message}`)); }
+                results.push({ tool_call_id: tc.id, result: res.text_for_model });
+                // O refino também precisa adicionar tool result no histórico isolado
+                refineMessages.push({ role: 'tool', tool_call_id: tc.id, content: res.text_for_model });
+                if (res.finish) refineDone = true;
+            }
+            refineToolResults = null; // já injetamos no refineMessages, não duplicar
+
+            // Prepara spinner do próximo turno de refino se ainda não terminou
+            if (!refineDone) refineSp = new Spinner('Melhorando').start();
+        }
+        if (refineSp) refineSp.stop();
+
+        // Executa aberturas adiadas agora que o refino terminou
+        if (deferredOpens.length > 0) {
+            for (const target of deferredOpens) {
+                console.log('\n' + toolLine('Open', target));
+                try {
+                    const res = await tools.executeTool('open_in_browser', { target }, log);
+                    if (!res.ok && res.text_for_model) {
+                        console.log(c.muted('  ⎿ ' + (res.error || 'ok')));
+                    }
+                } catch (e) {
+                    console.log(c.err(`  ⎿ falha: ${e.message}`));
+                }
+            }
+        }
+    } else if (deferredOpens.length > 0) {
+        // Não houve refino mas há aberturas adiadas — executa direto (fallback)
+        for (const target of deferredOpens) {
+            console.log('\n' + toolLine('Open', target));
+            try { await tools.executeTool('open_in_browser', { target }, log); }
+            catch (e) { console.log(c.err(`  ⎿ falha: ${e.message}`)); }
+        }
+    }
+
+    // Retorna a mensagem final para o caller anexar ao histórico do chat
+    // Consolidamos toda a atividade + texto final para o usuário poder referenciar depois
+    return {
+        userMessage: { role: 'user', content: userPrompt },
+        assistantMessage: { role: 'assistant', content: finalAssistantText || '[ação concluída]' },
+    };
+}
+
+module.exports = { runAct };

package/lib/api.js

@@ -0,0 +1,39 @@
+/**
+ * API client — comunicação com primocode-server
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+function request(serverUrl, endpoint, payload) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(endpoint, serverUrl);
+        const data = JSON.stringify(payload);
+        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data) } };
+        const client = url.protocol==='https:' ? https : http;
+        const req = client.request(options, (res) => { let body=''; res.on('data', c=>body+=c); res.on('end', () => { try { const json=JSON.parse(body); if (res.statusCode>=400) reject(new Error(json.erro||json.error||`HTTP ${res.statusCode}`)); else resolve(json); } catch { reject(new Error(`Resposta inválida: ${body.slice(0,200)}`)); } }); });
+        req.on('error', reject); req.write(data); req.end();
+    });
+}
+
+function requestStream(serverUrl, endpoint, payload, onEvent) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(endpoint, serverUrl);
+        const data = JSON.stringify(payload);
+        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data), 'Accept':'text/event-stream' } };
+        const client = url.protocol==='https:' ? https : http;
+        const req = client.request(options, (res) => { let buffer=''; res.on('data', chunk => { buffer+=chunk; const lines=buffer.split('\n'); buffer=lines.pop(); for (const line of lines) if (line.startsWith('data: ')) { try { const evt=JSON.parse(line.slice(6)); onEvent(evt); if (evt.done) resolve(); } catch {} } }); res.on('end', () => resolve()); });
+        req.on('error', reject); req.write(data); req.end();
+    });
+}
+
+function requestAct(serverUrl, messages, model) { return request(serverUrl, '/api/act', { messages, model }); }
+
+function getHealth(serverUrl) {
+    return new Promise((resolve, reject) => { const url=new URL('/health',serverUrl); const client=url.protocol==='https:'?https:http; const req=client.get(url, (res)=>{ let body=''; res.on('data',c=>body+=c); res.on('end',()=>{ try { resolve(JSON.parse(body)); } catch { reject(new Error('Resposta inválida do health check')); } }); }); req.on('error',reject); });
+}
+
+module.exports = { request, requestStream, requestAct, getHealth };