@omnivoice/page-agent 0.1.0 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@omnivoice/page-agent",
     "private": false,
-    "version": "0.1.0",
+    "version": "0.2.0",
     "type": "module",
     "main": "./dist/esm/page-agent.js",
     "types": "./dist/esm/PageAgent.d.ts",
@@ -13,7 +13,8 @@
         }
     },
     "files": [
-        "dist/"
+        "dist/",
+        "server/"
     ],
     "description": "GUI agent for web applications - add intelligent automation to any webpage with a single script",
     "keywords": [
@@ -39,10 +40,10 @@
         "postpublish": "node ../../scripts/post-publish.js"
     },
     "dependencies": {
-        "@omnivoice/core": "0.1.0",
-        "@omnivoice/llms": "0.1.0",
-        "@omnivoice/page-controller": "0.1.0",
-        "@omnivoice/ui": "0.1.0",
+        "@omnivoice/core": "0.2.0",
+        "@omnivoice/llms": "0.2.0",
+        "@omnivoice/page-controller": "0.2.0",
+        "@omnivoice/ui": "0.2.0",
         "chalk": "^6.0.0"
     },
     "peerDependencies": {
@@ -56,5 +57,8 @@
         "url": "git+https://github.com/SorPuti/page-agent-fork.git",
         "directory": "packages/page-agent"
     },
+    "bin": {
+        "omnivoice-agent-gateway": "server/agent-gateway.mjs"
+    },
     "module": "./dist/esm/page-agent.js"
 }

package/server/agent-gateway.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * FORK: gateway do agente — a casa da chave de API. O front-end NUNCA vê a chave: ele fala com
+ * este gateway (mesma origem do site do projeto) e o gateway injeta a chave ao chamar o modelo.
+ *
+ * Por que: colocar `apiKey` no HTML/JS expõe a chave a qualquer um que abrir o devtools. O
+ * padrão correto é: segredo só no servidor. Cada projeto roda o SEU gateway com a SUA config
+ * (modelo, URL do provedor, chave, voz), então o controle fica com o projeto, não com a página.
+ *
+ * Config (prioridade: env > arquivo JSON):
+ *   AGENT_BASE_URL     Endpoint OpenAI-compatible upstream. ex.: https://api.openai.com/v1
+ *   AGENT_API_KEY      Chave do provedor (SÓ aqui).
+ *   AGENT_MODEL        Modelo a usar. ex.: gpt-4o-mini
+ *   AGENT_LANGUAGE     pt-BR | en-US | zh-CN (default pt-BR)
+ *   AGENT_MAX_STEPS    Máx. de passos por tarefa (default 30)
+ *   AGENT_VOICE_INPUT  true/false — permite ditado no widget (default true)
+ *   AGENT_VOICE_OUTPUT true/false — agente fala o resultado (default false)
+ *   AGENT_VOICE_LANG   Idioma da voz (default = AGENT_LANGUAGE)
+ *   AGENT_PORT         Porta do gateway (default 8790)
+ *   AGENT_HOST         Bind (default 127.0.0.1 — local; use 0.0.0.0 só atrás de proxy seguro)
+ *   AGENT_CONFIG       Caminho p/ um agent.config.json com os mesmos campos (case-insensitive).
+ *
+ * Endpoints:
+ *   GET  /config                  → config PÚBLICA (sem chave) p/ o widget montar.
+ *   POST /v1/chat/completions     → proxy p/ ${AGENT_BASE_URL}/chat/completions, injetando a chave.
+ *   GET  /health                  → { ok, configured, model }
+ *
+ * Uso:
+ *   AGENT_API_KEY=sk-… AGENT_BASE_URL=https://api.openai.com/v1 AGENT_MODEL=gpt-4o-mini \
+ *     node agent-gateway.mjs
+ * Ou: npm i @omnivoice/page-agent && npx omnivoice-agent-gateway   (bin do pacote)
+ *
+ * Zero dependências (usa fetch global do Node 18+).
+ */
+import { createServer } from 'node:http'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+// ---- Config: env > arquivo JSON > default ----
+function loadFileConfig() {
+	const p = process.env.AGENT_CONFIG
+	if (!p) return {}
+	const abs = resolve(process.cwd(), p)
+	if (!existsSync(abs)) {
+		console.warn(`[gateway] AGENT_CONFIG aponta p/ arquivo inexistente: ${abs}`)
+		return {}
+	}
+	try {
+		return JSON.parse(readFileSync(abs, 'utf8'))
+	} catch (e) {
+		console.warn(`[gateway] AGENT_CONFIG inválido (${abs}): ${e.message}`)
+		return {}
+	}
+}
+
+function envBool(v, def) {
+	if (v === undefined || v === '') return def
+	return ['1', 'true', 'yes', 'on'].includes(String(v).toLowerCase())
+}
+
+const fileCfg = loadFileConfig()
+const pick = (envKey, fileKey, def) => {
+	const fromEnv = process.env[envKey]
+	if (fromEnv !== undefined && fromEnv !== '') return fromEnv
+	const fromFile = fileCfg[fileKey]
+	if (fromFile !== undefined && fromFile !== null && fromFile !== '') return fromFile
+	return def
+}
+
+const config = {
+	baseURL: String(pick('AGENT_BASE_URL', 'baseURL', '')).replace(/\/+$/, ''),
+	apiKey: String(pick('AGENT_API_KEY', 'apiKey', '')),
+	model: String(pick('AGENT_MODEL', 'model', 'gpt-4o-mini')),
+	language: String(pick('AGENT_LANGUAGE', 'language', 'pt-BR')),
+	maxSteps: Number(pick('AGENT_MAX_STEPS', 'maxSteps', 30)) || 30,
+	voice: {
+		input: envBool(pick('AGENT_VOICE_INPUT', 'voiceInput', 'true'), true),
+		output: envBool(pick('AGENT_VOICE_OUTPUT', 'voiceOutput', 'false'), false),
+		lang: String(pick('AGENT_VOICE_LANG', 'voiceLang', '')) || undefined,
+	},
+	promptForNextTask: envBool(pick('AGENT_PROMPT_NEXT', 'promptForNextTask', 'true'), true),
+	port: Number(pick('AGENT_PORT', 'port', 8790)) || 8790,
+	host: String(pick('AGENT_HOST', 'host', '127.0.0.1')),
+}
+
+// ---- Helpers ----
+function sendJson(res, status, obj) {
+	const body = JSON.stringify(obj)
+	res.writeHead(status, {
+		'content-type': 'application/json; charset=utf-8',
+		'content-length': Buffer.byteLength(body),
+		// Sem cache da config: o projeto pode trocar modelo/voz e querer efeito imediato.
+		'cache-control': 'no-store',
+	})
+	res.end(body)
+}
+
+// Config pública (o que pode ir pro front). A chave NUNCA sai daqui.
+function publicConfig() {
+	return {
+		model: config.model,
+		language: config.language,
+		maxSteps: config.maxSteps,
+		promptForNextTask: config.promptForNextTask,
+		voice: {
+			input: config.voice.input,
+			output: config.voice.output,
+			...(config.voice.lang && { lang: config.voice.lang }),
+		},
+	}
+}
+
+// ---- Proxy de chat/completions ----
+async function proxyCompletions(req, res) {
+	if (!config.baseURL) {
+		return sendJson(res, 503, { error: 'AGENT_BASE_URL não configurado no gateway' })
+	}
+	if (!config.apiKey) {
+		return sendJson(res, 503, { error: 'AGENT_API_KEY não configurada no gateway' })
+	}
+
+	let raw
+	try {
+		raw = await readBody(req)
+	} catch (e) {
+		return sendJson(res, 400, { error: `Corpo da request inválido: ${e.message}` })
+	}
+	let body
+	try {
+		body = raw ? JSON.parse(raw) : {}
+	} catch {
+		return sendJson(res, 400, { error: 'Corpo não é JSON válido' })
+	}
+
+	// O gateway é a autoridade do modelo: força o modelo configurado (o front não escolhe).
+	body.model = config.model
+
+	// Cabeçalhos: injeta a chave do servidor e DESCARTA qualquer Authorization do client,
+	// para que uma página comprometida não consiga usar outra chave/conta.
+	const headers = { 'content-type': 'application/json' }
+	if (config.apiKey) headers.authorization = `Bearer ${config.apiKey}`
+
+	let upstream
+	try {
+		upstream = await fetch(`${config.baseURL}/chat/completions`, {
+			method: 'POST',
+			headers,
+			body: JSON.stringify(body),
+		})
+	} catch (e) {
+		console.error('[gateway] falha ao chamar upstream:', e.message)
+		return sendJson(res, 502, { error: `Falha ao contatar o provedor: ${e.message}` })
+	}
+
+	// Encaminha o corpo (stream ou JSON) e o status, sem vazar headers do provedor.
+	const text = await upstream.text()
+	res.writeHead(upstream.status, {
+		'content-type': upstream.headers.get('content-type') ?? 'application/json; charset=utf-8',
+		'cache-control': 'no-store',
+	})
+	res.end(text)
+}
+
+// Lê o corpo da request com limite (evita estouro de memória com payload gigante).
+const MAX_BODY = 2 * 1024 * 1024
+function readBody(req) {
+	return new Promise((resolveP, rejectP) => {
+		let size = 0
+		const chunks = []
+		req.on('data', c => {
+			size += c.length
+			if (size > MAX_BODY) {
+				rejectP(new Error('payload muito grande'))
+				req.destroy()
+				return
+			}
+			chunks.push(c)
+		})
+		req.on('end', () => resolveP(Buffer.concat(chunks).toString('utf8')))
+		req.on('error', rejectP)
+	})
+}
+
+// ---- Servidor ----
+const server = createServer(async (req, res) => {
+	const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`)
+	const path = url.pathname
+
+	try {
+		if (req.method === 'GET' && path === '/config') {
+			return sendJson(res, 200, publicConfig())
+		}
+		if (req.method === 'GET' && path === '/health') {
+			return sendJson(res, 200, {
+				ok: true,
+				configured: Boolean(config.apiKey && config.baseURL),
+				model: config.model,
+			})
+		}
+		if (req.method === 'POST' && path === '/v1/chat/completions') {
+			return await proxyCompletions(req, res)
+		}
+		return sendJson(res, 404, { error: `Rota não encontrada: ${req.method} ${path}` })
+	} catch (e) {
+		console.error('[gateway] erro não tratado:', e)
+		if (!res.headersSent) sendJson(res, 500, { error: 'Erro interno do gateway' })
+	}
+})
+
+server.listen(config.port, config.host, () => {
+	console.log(`[gateway] agente ouvindo em http://${config.host}:${config.port}`)
+	console.log(`[gateway]   model=${config.model}  language=${config.language}  voice=${JSON.stringify(config.voice)}`)
+	console.log(`[gateway]   chave configurada: ${config.apiKey ? 'sim (mantida no servidor)' : 'NÃO — defina AGENT_API_KEY'}`)
+	console.log(`[gateway]   upstream: ${config.baseURL || '(não definido)'}`)
+})