Implement API key authentication for enhanced NeoAPI security

Add API key generation, validation, and revocation endpoints to the API server, along with a JavaScript client for frontend integration.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: e3ff2484-bbd8-4aba-bea0-1940769b874a
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: b75b4233-01b4-45d5-b7c0-6e836674316e
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/1739408b-93a5-479b-a658-30f2493b0467/e3ff2484-bbd8-4aba-bea0-1940769b874a/eHvZpi8
Replit-Helium-Checkpoint-Created: true

artifacts/api-server/data/api-keys.json

@@ -0,0 +1,10 @@
+[
+  {
+    "key": "neo1-0ebbf10959c3ac6d2023d9e9f3111f0051c91a0d",
+    "name": "mi-pagina-web",
+    "createdAt": "2026-04-14T21:31:10.658Z",
+    "active": true,
+    "usageCount": 1,
+    "lastUsed": "2026-04-14T21:31:15.634Z"
+  }
+]

artifacts/api-server/src/lib/apiKeys.ts

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+const DATA_DIR = path.join(process.cwd(), "data");
+const KEYS_FILE = path.join(DATA_DIR, "api-keys.json");
+
+export interface ApiKey {
+  key: string;
+  name: string;
+  createdAt: string;
+  active: boolean;
+  usageCount: number;
+  lastUsed: string | null;
+}
+
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+  }
+}
+
+function readKeys(): ApiKey[] {
+  ensureDataDir();
+  if (!fs.existsSync(KEYS_FILE)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(KEYS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function writeKeys(keys: ApiKey[]) {
+  ensureDataDir();
+  fs.writeFileSync(KEYS_FILE, JSON.stringify(keys, null, 2), "utf-8");
+}
+
+export function generateKey(name: string): ApiKey {
+  const keys = readKeys();
+  const newKey: ApiKey = {
+    key: `neo1-${crypto.randomBytes(20).toString("hex")}`,
+    name,
+    createdAt: new Date().toISOString(),
+    active: true,
+    usageCount: 0,
+    lastUsed: null,
+  };
+  keys.push(newKey);
+  writeKeys(keys);
+  return newKey;
+}
+
+export function listKeys(): Omit<ApiKey, "key">[] {
+  return readKeys().map(({ key, ...rest }) => ({
+    ...rest,
+    keyPreview: `${key.slice(0, 10)}...${key.slice(-4)}`,
+  })) as Omit<ApiKey, "key">[];
+}
+
+export function validateKey(key: string): ApiKey | null {
+  const keys = readKeys();
+  const found = keys.find((k) => k.key === key && k.active);
+  if (!found) return null;
+
+  found.usageCount += 1;
+  found.lastUsed = new Date().toISOString();
+  writeKeys(keys);
+  return found;
+}
+
+export function revokeKey(keyOrName: string): boolean {
+  const keys = readKeys();
+  const idx = keys.findIndex(
+    (k) => k.key === keyOrName || k.name === keyOrName
+  );
+  if (idx === -1) return false;
+  keys[idx].active = false;
+  writeKeys(keys);
+  return true;
+}
+
+export function getAdminSecret(): string {
+  return process.env["NEO_ADMIN_SECRET"] ?? "neo-admin-change-me";
+}

artifacts/api-server/src/middlewares/auth.ts

@@ -0,0 +1,32 @@
+import { Request, Response, NextFunction } from "express";
+import { validateKey, getAdminSecret } from "../lib/apiKeys.js";
+
+export function requireApiKey(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers["authorization"] ?? "";
+  const key = authHeader.startsWith("Bearer ")
+    ? authHeader.slice(7).trim()
+    : (req.headers["x-api-key"] as string | undefined)?.trim() ?? "";
+
+  if (!key) {
+    res.status(401).json({ error: "API key requerida. Usa el header: Authorization: Bearer <tu-key>" });
+    return;
+  }
+
+  const found = validateKey(key);
+  if (!found) {
+    res.status(403).json({ error: "API key inválida o revocada." });
+    return;
+  }
+
+  (req as any).apiKey = found;
+  next();
+}
+
+export function requireAdmin(req: Request, res: Response, next: NextFunction) {
+  const secret = req.headers["x-admin-secret"] as string | undefined;
+  if (!secret || secret !== getAdminSecret()) {
+    res.status(403).json({ error: "Admin secret incorrecto." });
+    return;
+  }
+  next();
+}

artifacts/api-server/src/routes/index.ts

@@ -1,8 +1,12 @@
 import { Router, type IRouter } from "express";
-import healthRouter from "./health";
+import healthRouter from "./health.js";
+import keysRouter from "./keys.js";
+import neoRouter from "./neo.js";
 
 const router: IRouter = Router();
 
 router.use(healthRouter);
+router.use(keysRouter);
+router.use(neoRouter);
 
 export default router;

artifacts/api-server/src/routes/keys.ts

@@ -0,0 +1,36 @@
+import { Router } from "express";
+import { requireAdmin } from "../middlewares/auth.js";
+import { generateKey, listKeys, revokeKey } from "../lib/apiKeys.js";
+
+const router = Router();
+
+router.post("/keys", requireAdmin, (req, res) => {
+  const { name } = req.body as { name?: string };
+  if (!name || typeof name !== "string" || !name.trim()) {
+    res.status(400).json({ error: "El campo 'name' es obligatorio." });
+    return;
+  }
+  const key = generateKey(name.trim());
+  res.status(201).json({
+    message: "API key generada. Guárdala, no se vuelve a mostrar.",
+    key: key.key,
+    name: key.name,
+    createdAt: key.createdAt,
+  });
+});
+
+router.get("/keys", requireAdmin, (_req, res) => {
+  res.json({ keys: listKeys() });
+});
+
+router.delete("/keys/:name", requireAdmin, (req, res) => {
+  const { name } = req.params;
+  const ok = revokeKey(name!);
+  if (!ok) {
+    res.status(404).json({ error: "Key no encontrada o ya revocada." });
+    return;
+  }
+  res.json({ message: `Key '${name}' revocada.` });
+});
+
+export default router;

artifacts/api-server/src/routes/neo.ts

@@ -0,0 +1,58 @@
+import { Router } from "express";
+import { requireApiKey } from "../middlewares/auth.js";
+
+const router = Router();
+const NEO_REST_URL = "http://localhost:5001";
+
+router.post("/neo/chat", requireApiKey, async (req, res) => {
+  const { message, history = [] } = req.body as {
+    message?: string;
+    history?: Array<{ role: string; content: string }>;
+  };
+
+  if (!message || typeof message !== "string" || !message.trim()) {
+    res.status(400).json({ error: "El campo 'message' es obligatorio." });
+    return;
+  }
+
+  try {
+    const response = await fetch(`${NEO_REST_URL}/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message: message.trim(), history }),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      res.status(502).json({ error: "Error del modelo NEO-1", detail: err });
+      return;
+    }
+
+    const data = await response.json() as { response: string; model: string; status: string };
+    res.json({
+      response: data.response,
+      model: data.model ?? "mdfjbots-neo-1",
+      status: "ok",
+    });
+  } catch (err: any) {
+    res.status(503).json({
+      error: "No se pudo conectar con el modelo NEO-1. ¿Está corriendo?",
+      detail: err?.message ?? String(err),
+    });
+  }
+});
+
+router.get("/neo/models", requireApiKey, (_req, res) => {
+  res.json({
+    models: [
+      {
+        id: "mdfjbots-neo-1",
+        name: "NEO-1",
+        description: "Asistente conversacional con soporte de Roblox, calculadora y temas educativos.",
+        version: "1.13.1",
+      },
+    ],
+  });
+});
+
+export default router;

chat-app/app.py

@@ -1,142 +1,17 @@
 import os
-import re
-import json
 import time
 import gradio as gr
+from neo_rest import iniciar_servidor
+from logica import (
+    buscar_respuesta_personalizada, generar_explicacion_juego,
+    detectar_roblox, modo_calculadora_activo, extraer_texto_content,
+)
 from roblox_api import buscar_jugador, buscar_juego, formatear_jugador, formatear_juego
 from matematicas import (
     es_solicitud_calculadora, es_operacion_matematica,
-    resolver_operacion, formatear_resultado, extraer_nombre_usuario
+    resolver_operacion, formatear_resultado, extraer_nombre_usuario,
 )
 
-GENEROS_ROBLOX = {
-    "Town and City": "un juego de vida urbana y roleplay social",
-    "Adventure": "un juego de aventura y exploración",
-    "Role Playing": "un juego de rol donde puedes ser quien quieras",
-    "Comedy": "un juego de comedia y entretenimiento",
-    "Action": "un juego de acción y combate",
-    "Horror": "un juego de terror y suspenso",
-    "Military": "un juego de temática militar y estrategia",
-    "Medieval": "un juego de temática medieval con castillos y caballeros",
-    "Naval": "un juego de aventuras navales y piratas",
-    "Sci-Fi": "un juego de ciencia ficción",
-    "Sports": "un juego deportivo",
-    "Fighting": "un juego de peleas y combate",
-    "Western": "un juego de temática del lejano oeste",
-    "FPS": "un juego de disparos en primera persona",
-    "Building": "un juego de construcción y creatividad",
-    "Simulator": "un simulador",
-    "Tycoon": "un juego de gestión y negocios (tycoon)",
-    "Obby": "un juego de obstáculos (obby)",
-    "All Genres": "un juego variado",
-}
-
-def cargar_respuestas():
-    ruta = os.path.join(os.path.dirname(__file__), "respuestas.json")
-    try:
-        with open(ruta, "r", encoding="utf-8") as f:
-            datos = json.load(f)
-            return datos.get("respuestas", [])
-    except Exception:
-        return []
-
-RESPUESTAS_PERSONALIZADAS = cargar_respuestas()
-
-def buscar_respuesta_personalizada(mensaje):
-    texto = mensaje.lower().strip()
-    for entrada in RESPUESTAS_PERSONALIZADAS:
-        for pregunta in entrada.get("preguntas", []):
-            if pregunta.lower() in texto or texto in pregunta.lower():
-                return entrada.get("respuesta")
-    return None
-
-def generar_explicacion_juego(datos):
-    nombre = datos.get("nombre", "Este juego")
-    tema = datos.get("tema", "")
-    descripcion = datos.get("descripcion", "").strip()
-    visitas = datos.get("visitas", 0)
-    creador = datos.get("creador", "")
-
-    tipo = GENEROS_ROBLOX.get(tema, f"un juego de {tema.lower()}" if tema else "un juego")
-
-    partes = [f"**{nombre}** es {tipo} de Roblox creado por **{creador}**."]
-
-    if descripcion and descripcion != "Sin descripción.":
-        desc_corta = descripcion[:200] + ("..." if len(descripcion) > 200 else "")
-        partes.append(f"Según su descripción oficial: *\"{desc_corta}\"*")
-
-    try:
-        v = int(visitas)
-        if v >= 1_000_000_000:
-            partes.append(f"Es uno de los juegos más visitados de Roblox con más de {v // 1_000_000_000} mil millones de visitas.")
-        elif v >= 1_000_000:
-            partes.append(f"Cuenta con más de {v // 1_000_000} millones de visitas en total.")
-        elif v >= 1_000:
-            partes.append(f"Cuenta con más de {v // 1_000}K visitas en total.")
-    except Exception:
-        pass
-
-    return " ".join(partes)
-
-PATRONES_JUGADOR = [
-    r"buscar\s+jugador\s+(.+)",
-    r"busca\s+jugador\s+(.+)",
-    r"jugador\s+de\s+roblox\s+(.+)",
-    r"usuario\s+de\s+roblox\s+(.+)",
-    r"perfil\s+de\s+roblox\s+(.+)",
-    r"buscar\s+usuario\s+(.+)",
-    r"busca\s+usuario\s+(.+)",
-    r"quien\s+es\s+(.+)\s+en\s+roblox",
-    r"quién\s+es\s+(.+)\s+en\s+roblox",
-    r"info\s+de\s+(.+)\s+roblox",
-]
-
-PATRONES_JUEGO = [
-    r"buscar\s+juego\s+(.+)",
-    r"busca\s+juego\s+(.+)",
-    r"juego\s+de\s+roblox\s+(.+)",
-    r"buscar\s+(.+)\s+en\s+roblox",
-    r"busca\s+(.+)\s+en\s+roblox",
-    r"información\s+del\s+juego\s+(.+)",
-    r"informacion\s+del\s+juego\s+(.+)",
-]
-
-def detectar_roblox(mensaje):
-    texto = mensaje.lower().strip()
-    for patron in PATRONES_JUGADOR:
-        m = re.search(patron, texto)
-        if m:
-            return "jugador", m.group(1).strip()
-    for patron in PATRONES_JUEGO:
-        m = re.search(patron, texto)
-        if m:
-            return "juego", m.group(1).strip()
-    return None, None
-
-def extraer_texto_content(content):
-    if not content:
-        return ""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        partes = []
-        for bloque in content:
-            if isinstance(bloque, str):
-                partes.append(bloque)
-            elif isinstance(bloque, dict):
-                partes.append(str(bloque.get("text") or bloque.get("value") or bloque.get("content") or ""))
-        return " ".join(partes)
-    return str(content)
-
-def modo_calculadora_activo(historial):
-    if not historial:
-        return False
-    for msg in reversed(historial):
-        if msg.get("role") == "assistant":
-            texto = extraer_texto_content(msg.get("content")).lower()
-            return "calculadora neo-1" in texto or "aquí tienes nuestra calculadora" in texto
-    return False
-
 def añadir_turno(historial, user_msg, bot_msg=""):
     return historial + [
         {"role": "user", "content": user_msg},
@@ -199,11 +74,9 @@ def responder(mensaje, historial):
         yield historial, ""
         datos = buscar_juego(nombre_roblox)
         resultado = formatear_juego(datos)
-
         if datos and "error" not in datos:
             explicacion = generar_explicacion_juego(datos)
             resultado = resultado + "\n\n💡 **¿De qué trata el juego?**\n" + explicacion
-
         historial[-1]["content"] = resultado
         yield historial, ""
         return
@@ -259,22 +132,13 @@ with gr.Blocks(title="mdfjbots-neo-1") as demo:
         label="Ejemplos de preguntas",
     )
 
-    entrada.submit(
-        fn=responder,
-        inputs=[entrada, chatbot],
-        outputs=[chatbot, entrada],
-    )
-    btn_enviar.click(
-        fn=responder,
-        inputs=[entrada, chatbot],
-        outputs=[chatbot, entrada],
-    )
-    btn_limpiar.click(
-        fn=lambda: ([], ""),
-        outputs=[chatbot, entrada],
-    )
+    entrada.submit(fn=responder, inputs=[entrada, chatbot], outputs=[chatbot, entrada])
+    btn_enviar.click(fn=responder, inputs=[entrada, chatbot], outputs=[chatbot, entrada])
+    btn_limpiar.click(fn=lambda: ([], ""), outputs=[chatbot, entrada])
 
 if __name__ == "__main__":
+    iniciar_servidor()
+
     port = int(os.environ.get("PORT", 5000))
     dev_domain = os.environ.get("REPLIT_DEV_DOMAIN", "")
     root_path = f"https://{dev_domain}/__neo1" if dev_domain else ""

chat-app/logica.py

@@ -0,0 +1,176 @@
+import os
+import re
+import json
+from roblox_api import buscar_jugador, buscar_juego, formatear_jugador, formatear_juego
+from matematicas import (
+    es_solicitud_calculadora, es_operacion_matematica,
+    resolver_operacion, formatear_resultado, extraer_nombre_usuario,
+)
+
+GENEROS_ROBLOX = {
+    "Town and City": "un juego de vida urbana y roleplay social",
+    "Adventure": "un juego de aventura y exploración",
+    "Role Playing": "un juego de rol donde puedes ser quien quieras",
+    "Comedy": "un juego de comedia y entretenimiento",
+    "Action": "un juego de acción y combate",
+    "Horror": "un juego de terror y suspenso",
+    "Military": "un juego de temática militar y estrategia",
+    "Medieval": "un juego de temática medieval con castillos y caballeros",
+    "Naval": "un juego de aventuras navales y piratas",
+    "Sci-Fi": "un juego de ciencia ficción",
+    "Sports": "un juego deportivo",
+    "Fighting": "un juego de peleas y combate",
+    "Western": "un juego de temática del lejano oeste",
+    "FPS": "un juego de disparos en primera persona",
+    "Building": "un juego de construcción y creatividad",
+    "Simulator": "un simulador",
+    "Tycoon": "un juego de gestión y negocios (tycoon)",
+    "Obby": "un juego de obstáculos (obby)",
+    "All Genres": "un juego variado",
+}
+
+def cargar_respuestas():
+    ruta = os.path.join(os.path.dirname(__file__), "respuestas.json")
+    try:
+        with open(ruta, "r", encoding="utf-8") as f:
+            datos = json.load(f)
+            return datos.get("respuestas", [])
+    except Exception:
+        return []
+
+RESPUESTAS_PERSONALIZADAS = cargar_respuestas()
+
+def buscar_respuesta_personalizada(mensaje):
+    texto = mensaje.lower().strip()
+    for entrada in RESPUESTAS_PERSONALIZADAS:
+        for pregunta in entrada.get("preguntas", []):
+            if pregunta.lower() in texto or texto in pregunta.lower():
+                return entrada.get("respuesta")
+    return None
+
+def generar_explicacion_juego(datos):
+    nombre = datos.get("nombre", "Este juego")
+    tema = datos.get("tema", "")
+    descripcion = datos.get("descripcion", "").strip()
+    visitas = datos.get("visitas", 0)
+    creador = datos.get("creador", "")
+
+    tipo = GENEROS_ROBLOX.get(tema, f"un juego de {tema.lower()}" if tema else "un juego")
+    partes = [f"**{nombre}** es {tipo} de Roblox creado por **{creador}**."]
+
+    if descripcion and descripcion != "Sin descripción.":
+        desc_corta = descripcion[:200] + ("..." if len(descripcion) > 200 else "")
+        partes.append(f"Según su descripción oficial: *\"{desc_corta}\"*")
+
+    try:
+        v = int(visitas)
+        if v >= 1_000_000_000:
+            partes.append(f"Es uno de los juegos más visitados de Roblox con más de {v // 1_000_000_000} mil millones de visitas.")
+        elif v >= 1_000_000:
+            partes.append(f"Cuenta con más de {v // 1_000_000} millones de visitas en total.")
+        elif v >= 1_000:
+            partes.append(f"Cuenta con más de {v // 1_000}K visitas en total.")
+    except Exception:
+        pass
+
+    return " ".join(partes)
+
+PATRONES_JUGADOR = [
+    r"buscar\s+jugador\s+(.+)",
+    r"busca\s+jugador\s+(.+)",
+    r"jugador\s+de\s+roblox\s+(.+)",
+    r"usuario\s+de\s+roblox\s+(.+)",
+    r"perfil\s+de\s+roblox\s+(.+)",
+    r"buscar\s+usuario\s+(.+)",
+    r"busca\s+usuario\s+(.+)",
+    r"quien\s+es\s+(.+)\s+en\s+roblox",
+    r"quién\s+es\s+(.+)\s+en\s+roblox",
+    r"info\s+de\s+(.+)\s+roblox",
+]
+
+PATRONES_JUEGO = [
+    r"buscar\s+juego\s+(.+)",
+    r"busca\s+juego\s+(.+)",
+    r"juego\s+de\s+roblox\s+(.+)",
+    r"buscar\s+(.+)\s+en\s+roblox",
+    r"busca\s+(.+)\s+en\s+roblox",
+    r"información\s+del\s+juego\s+(.+)",
+    r"informacion\s+del\s+juego\s+(.+)",
+]
+
+def detectar_roblox(mensaje):
+    texto = mensaje.lower().strip()
+    for patron in PATRONES_JUGADOR:
+        m = re.search(patron, texto)
+        if m:
+            return "jugador", m.group(1).strip()
+    for patron in PATRONES_JUEGO:
+        m = re.search(patron, texto)
+        if m:
+            return "juego", m.group(1).strip()
+    return None, None
+
+def extraer_texto_content(content):
+    if not content:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        partes = []
+        for bloque in content:
+            if isinstance(bloque, str):
+                partes.append(bloque)
+            elif isinstance(bloque, dict):
+                partes.append(str(bloque.get("text") or bloque.get("value") or bloque.get("content") or ""))
+        return " ".join(partes)
+    return str(content)
+
+def modo_calculadora_activo(historial):
+    if not historial:
+        return False
+    for msg in reversed(historial):
+        if isinstance(msg, dict) and msg.get("role") == "assistant":
+            texto = extraer_texto_content(msg.get("content")).lower()
+            return "calculadora neo-1" in texto or "aquí tienes nuestra calculadora" in texto
+    return False
+
+def respuesta_final(mensaje, historial):
+    texto = mensaje.strip().lower()
+
+    if es_solicitud_calculadora(mensaje):
+        nombre = extraer_nombre_usuario(historial)
+        return (
+            f"Claro 😀, {nombre} aquí tienes nuestra calculadora:\n\n"
+            "🧮 **Calculadora Virtual NEO-1**\n"
+            "Escribe cualquier operación matemática y la resolveré al instante.\n\n"
+            "**Ejemplos:** `5 + 3`, `12 * 7`, `100 / 4`, `2 ** 8` (potencia)\n\n"
+            "_Escribe tu operación o di 'salir de calculadora' para volver._"
+        )
+
+    if texto in ("salir de calculadora", "salir calculadora", "cerrar calculadora", "volver al chat"):
+        return "De acuerdo, volviendo al chat normal. ¡Pregúntame lo que quieras! 😊"
+
+    if modo_calculadora_activo(historial) or es_operacion_matematica(mensaje):
+        resultado = resolver_operacion(mensaje)
+        if resultado is not None:
+            return formatear_resultado(mensaje, resultado)
+
+    tipo_roblox, nombre_roblox = detectar_roblox(mensaje)
+
+    if tipo_roblox == "jugador":
+        datos = buscar_jugador(nombre_roblox)
+        return formatear_jugador(datos)
+
+    if tipo_roblox == "juego":
+        datos = buscar_juego(nombre_roblox)
+        resultado = formatear_juego(datos)
+        if datos and "error" not in datos:
+            explicacion = generar_explicacion_juego(datos)
+            resultado = resultado + "\n\n💡 **¿De qué trata el juego?**\n" + explicacion
+        return resultado
+
+    respuesta = buscar_respuesta_personalizada(mensaje)
+    if respuesta:
+        return respuesta
+
+    return "🤖 NEO-1 aún no tiene una respuesta para eso. Puedes enseñarle más temas agregando respuestas al modelo."

chat-app/neo_rest.py

@@ -0,0 +1,62 @@
+import json
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(__file__))
+from logica import respuesta_final
+
+NEO_REST_PORT = 5001
+
+class NeoAPIHandler(BaseHTTPRequestHandler):
+    def _send_json(self, code, data):
+        body = json.dumps(data, ensure_ascii=False).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self):
+        if self.path == "/chat":
+            try:
+                length = int(self.headers.get("Content-Length", 0))
+                raw = self.rfile.read(length)
+                data = json.loads(raw)
+
+                mensaje = str(data.get("message", "")).strip()
+                historial = data.get("history", [])
+
+                if not mensaje:
+                    self._send_json(400, {"error": "El campo 'message' es obligatorio"})
+                    return
+
+                respuesta = respuesta_final(mensaje, historial)
+                self._send_json(200, {
+                    "response": respuesta,
+                    "model": "mdfjbots-neo-1",
+                    "status": "ok",
+                })
+            except json.JSONDecodeError:
+                self._send_json(400, {"error": "JSON inválido"})
+            except Exception as e:
+                self._send_json(500, {"error": str(e)})
+        else:
+            self._send_json(404, {"error": "Ruta no encontrada"})
+
+    def do_GET(self):
+        if self.path == "/health":
+            self._send_json(200, {"status": "ok", "model": "mdfjbots-neo-1"})
+        else:
+            self._send_json(404, {"error": "Ruta no encontrada"})
+
+    def log_message(self, format, *args):
+        pass
+
+def iniciar_servidor():
+    server = HTTPServer(("0.0.0.0", NEO_REST_PORT), NeoAPIHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    print(f"[NeoAPI REST] Corriendo en http://0.0.0.0:{NEO_REST_PORT}")
+    return server

neo-api-client.js

@@ -0,0 +1,149 @@
+/**
+ * NeoAPI Client — mdfjbots-neo-1
+ * Úsalo en tu página web para conectarte con la NeoAPI.
+ *
+ * Uso básico:
+ *   const neo = new NeoAPI("neo1-tu_api_key_aqui");
+ *   const respuesta = await neo.chat("Hola, ¿quién eres?");
+ *   console.log(respuesta);
+ */
+
+class NeoAPI {
+  /**
+   * @param {string} apiKey   - Tu API key (formato: neo1-...)
+   * @param {string} [baseUrl] - URL base de la NeoAPI (opcional, por defecto la URL de producción)
+   */
+  constructor(apiKey, baseUrl = "https://TU_DOMINIO_AQUI/api") {
+    if (!apiKey) throw new Error("NeoAPI: se requiere una API key.");
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.history = [];
+  }
+
+  /**
+   * Envía un mensaje al modelo NEO-1 y obtiene la respuesta.
+   * El historial de conversación se mantiene automáticamente.
+   *
+   * @param {string} message - El mensaje del usuario
+   * @returns {Promise<string>} - La respuesta del modelo
+   */
+  async chat(message) {
+    const response = await fetch(`${this.baseUrl}/neo/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        message,
+        history: this.history,
+      }),
+    });
+
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(`NeoAPI error ${response.status}: ${err.error ?? response.statusText}`);
+    }
+
+    const data = await response.json();
+    const botReply = data.response;
+
+    this.history.push(
+      { role: "user", content: message },
+      { role: "assistant", content: botReply }
+    );
+
+    return botReply;
+  }
+
+  /**
+   * Envía un mensaje sin mantener historial (cada llamada es independiente).
+   *
+   * @param {string} message - El mensaje del usuario
+   * @param {Array}  [history] - Historial opcional a enviar
+   * @returns {Promise<string>}
+   */
+  async chatOnce(message, history = []) {
+    const response = await fetch(`${this.baseUrl}/neo/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({ message, history }),
+    });
+
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(`NeoAPI error ${response.status}: ${err.error ?? response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data.response;
+  }
+
+  /** Limpia el historial de conversación. */
+  clearHistory() {
+    this.history = [];
+  }
+
+  /** Obtiene los modelos disponibles. */
+  async getModels() {
+    const response = await fetch(`${this.baseUrl}/neo/models`, {
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+    });
+    if (!response.ok) throw new Error("NeoAPI: error al obtener modelos.");
+    return response.json();
+  }
+}
+
+/**
+ * ─────────────────────────────────────────────
+ *  EJEMPLOS DE USO
+ * ─────────────────────────────────────────────
+ *
+ * 1) Conversación simple:
+ *
+ *   const neo = new NeoAPI("neo1-tu_api_key");
+ *   const res = await neo.chat("¿Qué es Linux?");
+ *   document.getElementById("respuesta").textContent = res;
+ *
+ *
+ * 2) Chatbot con historial en la página:
+ *
+ *   const neo = new NeoAPI("neo1-tu_api_key");
+ *
+ *   async function enviar() {
+ *     const input = document.getElementById("input").value;
+ *     const res = await neo.chat(input);
+ *     mostrarMensaje("NEO-1", res);
+ *   }
+ *
+ *
+ * 3) Llamada directa sin historial (para búsquedas puntuales):
+ *
+ *   const neo = new NeoAPI("neo1-tu_api_key");
+ *   const res = await neo.chatOnce("buscar juego Adopt Me");
+ *   console.log(res);
+ *
+ *
+ * ─────────────────────────────────────────────
+ *  ENDPOINTS DE ADMIN (para gestionar API keys)
+ *  Se hacen desde tu backend, nunca desde el frontend.
+ * ─────────────────────────────────────────────
+ *
+ * Crear una nueva key:
+ *   POST /api/keys
+ *   Header: x-admin-secret: TU_ADMIN_SECRET
+ *   Body: { "name": "mi-app-web" }
+ *
+ * Listar keys:
+ *   GET /api/keys
+ *   Header: x-admin-secret: TU_ADMIN_SECRET
+ *
+ * Revocar una key:
+ *   DELETE /api/keys/mi-app-web
+ *   Header: x-admin-secret: TU_ADMIN_SECRET
+ */
+
+export default NeoAPI;