diff --git a/servicios/nexxa/.gitignore b/servicios/nexxa/.gitignore deleted file mode 100644 index 82045d96..00000000 --- a/servicios/nexxa/.gitignore +++ /dev/null @@ -1,17 +0,0 @@ -# Estado y secretos de NEXXA: viven SOLO en el nodo (srvv-nexxa:/opt/nexxa), nunca en el repo (Regla de Oro 15). -.env -*.conf -organismo/.master_key -organismo/.usuarios.json -organismo/.sessions.json -organismo/registro.json -organismo/tokens.json -organismo/checkins.json -organismo/pools.json -organismo/*.log -*.bak* -organismo/COMMIT -# Motor archivo de Nexxa::Estado (P335/Fase 17): bloqueos de mutar, temporales de escritura atómica y respaldos de cli_estado -organismo/*.lock -organismo/*.tmp-* -organismo/bkp_estado_*.tgz diff --git a/servicios/nexxa/MUDADO.md b/servicios/nexxa/MUDADO.md new file mode 100644 index 00000000..0b18f728 --- /dev/null +++ b/servicios/nexxa/MUDADO.md @@ -0,0 +1,10 @@ +# NEXXA se mudó + +Desde el 2026-10-05 (P338/Fase 1, convención de servicios por servidor) el código de NEXXA vive en el repo +**dtic-GEMMA**, junto a la ficha del servicio: + + dtic-GEMMA/_docs/DIIAA/_servers/srvv-nexxa/servicios/NEXXA/ + NEXXA.md ficha del servicio + app-web/ el código (lo que antes estaba acá) + +El historial de commits hasta la mudanza queda en este repo (dtic-DIIAA). Se despliega con `gemma nexxa desplegar`. diff --git a/servicios/nexxa/README.md b/servicios/nexxa/README.md deleted file mode 100644 index 77983f6d..00000000 --- a/servicios/nexxa/README.md +++ /dev/null @@ -1,42 +0,0 @@ -# NEXXA — broker de API keys del ecosistema (servicio DIIAA) - -NEXXA administra el pool de API keys (Gemini, DeepSeek, …) que consumen GEMMA y los individuos F1: dispensa una key -por consulta, cifrada de punta a punta para el consumidor, y recibe el reporte de salud de cada key. Se gestiona desde -**nexxa-web** (`web/`, panel con usuarios admin/operador) y se consume por su API HTTP (`organismo/server.rb`, :4568). - -## Origen y versión - -- **Versión vigente:** `organismo/VERSION` (fuente única; nexxa-web la muestra en `/version`). -- **Metamorfosis (2026-10-04, P335):** nació como el individuo `rm-apid06-nexxa` del linaje apids (repo `rm-APIDs`, - P201/P204/P205/P238). Pasa a ser el servicio `srvv-nexxa` del ámbito DIIAA: es la misma NEXXA, evolucionada. -- **Base de este repo:** el código que corría en producción el 2026-10-04 (versión 1.2.1), importado y verificado por - hash contra el nodo (`gemma git importar:verificar`, 23/23 iguales). El repo `rm-APIDs` había quedado atrasado desde - P201 (6 archivos distintos o ausentes). - -## Estructura (convención REG002, P335/Fase 9) - -- `organismo/lib_*.rb`: módulos (registro, pools, tokens, auth, usos, checkins, cripto, envelope). -- `organismo/cli_*.rb`: CLIs de emergencia en el nodo (`cli_admin`, `cli_consumidor`, `cli_registrar`). -- `organismo/tool_humo_pool.rb`: humo que corre EN el nodo contra el registro real (provider descartable). -- Contratos externos con su nombre de siempre: `server.rb` (lo arranca systemd) y el chasis F1 `chat.rb`, `latido.rb`, - `nexxa.rb`, `router.rb` (los usa `gemma individuos chat`, igual en todos los individuos). -- `test/`: suite local sobre una copia aislada con estado falso (`ruby test/_test.rb`); `test/servidor_prueba.rb` - deja un NEXXA de prueba corriendo para mirar nexxa-web en un navegador. - -## Reglas - -- **El código se cambia acá y se despliega desde acá**, nunca editando en el nodo: - `gemma nodos deploy --nodo --local-dir servicios/nexxa/organismo --remoto-dir /opt/nexxa/organismo --archivos ...` - (verifica hash local == remoto). -- **Versión semver por release:** patch (arreglo), minor (función nueva compatible), major (cambia el contrato de la API). - Se sube `organismo/VERSION` en el mismo commit del cambio. -- **Estado y secretos nunca acá** (ver `.gitignore`): `registro.json`, `tokens.json`, usuarios, sesiones, la master key y - los logs viven solo en el nodo (Regla de Oro 15). -- **Estado en su Postgres propio** (P335/Fase 17, decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8 - caiga): todo pasa por `organismo/lib_estado.rb` (`Nexxa::Estado`), con motor `archivo` (JSON 0600, el de siempre y el - de los tests) o `pg` (base `nexxa` local, socket peer con el usuario del servicio, sin contraseña), elegido EXPLÍCITO con - `NEXXA_ESTADO=pg` en un drop-in systemd de los dos servicios. `mutar` es leer-modificar-guardar atómico y la dispensa - elige y reserva la key en un solo paso. Pasar de un motor al otro: `organismo/cli_estado.rb migrar|verificar|exportar`, - que desde GEMMA corre `gemma nexxa estado:pg --accion preparar|activar|revertir`. - -Plan vigente: `dtic-GEMMA/_docs/DIIAA/p_P335_nexxa-pools-por-individuo-mente-y-red-con-gestion-web.md`. diff --git a/servicios/nexxa/germen.md b/servicios/nexxa/germen.md deleted file mode 100644 index 9578f78c..00000000 --- a/servicios/nexxa/germen.md +++ /dev/null @@ -1,151 +0,0 @@ -# Germen — Individuo Circulatorio (rm-apid06-nexxa) - -## Entregar este archivo como primer mensaje a la IA ejecutora del nacimiento - -> Este germen NO es el de OpenClaw (Miguel, r-WEBs, PEGGY, ABBY). Aquellos hacen -> nacer un agente LLM-céntrico con gateway y canal conversacional. **Tampoco es** -> el de RUBBY, que aunque es chasis F1 nativo determinístico en runtime, sí lleva -> un Arquitecto (LLM) para génesis offline de piezas nuevas. **NEXXA nace sin -> ningún LLM, en ninguna capa, ni siquiera para su propia génesis** (decisión del -> Operador, P200/Fase2) — el organismo más minimalista del linaje hasta hoy. -> Reutiliza el *proceso* de nacimiento de RUBBY (checkpoints por etapa, -> separación script/individuo, secrets por env, gate entre etapas), no su -> *contenido*. - ---- - -## Tu misión - -Hacer nacer el **organismo mínimo viable** de rotación/fallback de API keys para -el equipo F1. De cara afuera, NEXXA responde consultas de sus pares vía -`apids chat` sobre qué key/provider está disponible ahora; por dentro es un -registro de estado (cuotas por provider) y una lógica de decisión puramente -determinística — sin capa de razonamiento en ningún punto del camino. - -**El diseño ya está hecho — no lo reinventes.** El delta de dominio completo -vive en `_docs/RM-LABs/rm-APIDs/D045_diseno-nexxa-f1.md` (repo dtic-GEMMA), y el -modelo F1 base en `D025`. Tu trabajo es **materializarlo**, no rediseñarlo. Si -algo del diseño no cierra contra la realidad del hábitat, lo reportás y esperás -decisión — no improvisás una variante. - -**Principio rector — diseño como objetivo, no receta:** este germen te da el *qué* -(el organismo a lograr, sus restricciones, su criterio de vida). El *cómo* -(estructura exacta de los archivos Ruby, comandos) lo investigás y resolvés vos -contra el hábitat real. - ---- - -## Etapa 1 — Relevamiento (antes de tocar nada) - -**Hábitat:** -- La LXC `rm-apid06-nexxa` en srv-pmox2 (VMID y recursos definidos en la corrida - de creación — ver Fase 3 del plan P200). Confirmá que existe, que arranca y que - tenés acceso SSH a ella. -- Ruby disponible dentro de la LXC. Es el único sustrato — no hay Node/OpenClaw - acá. -- NEXXA no necesita salida propia a internet para su función central (consulta - estado de cuotas que ya le llegaron por registro, no llama a los providers - directamente para verificar salud, al menos en el alcance mínimo de este - nacimiento — D045 §3 deja el contrato exacto a cerrar en esta misma fase). - -**Secrets — protocolo estricto, sin excepciones (ME-293):** -- NEXXA no tiene key LLM propia (no hay Arquitecto). Los secrets que sí maneja - son las **keys de terceros que registra en su base** (Gemini/Groq/… de otros - individuos) — nunca en el `.conf` versionado, siempre en `.env` o vía candados, - nunca en argv (ME-293). -- Verificás presencia de secrets contando, sin mostrar valores. - -Al cerrar el relevamiento: resumen (sin valores de secrets) y confirmación explícita -del operador antes de la Etapa 2. - ---- - -## Etapa 2 — El organismo a materializar (el objetivo, no la receta) - -Del diseño D045, dos órganos — ninguno con LLM: - -1. **Registro de cuotas** (`registro.json` o similar — nombre exacto a definir - contra el hábitat) — una sola fuente de verdad. Cada entrada: `provider`, - `email`/identificador de la key, `dueño` (individuo consumidor o - `compartida`), `disponible_desde` (mismo cálculo que `apirot.rb`, - `ultimo_uso + reset`). **Delta sobre apirot** (D045/P200 Fase2-2.3): NEXXA - nace con registro propio y limpio, inspirado en el concepto de apirot pero no - dependiente de su código ni de su archivo — apirot.rb sigue existiendo tal - cual para uso interno de GEMMA. - -2. **Router de consulta** (`maestro.rb` o equivalente mínimo) — matching exacto - `estímulo → respuesta de estado`, cero semántica en runtime, cero LLM. Ante - consulta "¿qué key uso para provider X?": busca en el registro la primera con - `disponible_desde <= ahora`; si ninguna, responde explícito y accionable (ej. - `GEMINI: agotado, próxima en 2h15m`), nunca silencioso (D045 §0, patrón ya - usado en el linaje). - -**Sin Arquitecto, sin telemetría de génesis** (a diferencia de RUBBY/D025 §5): -no hay génesis reactiva que medir — si en el futuro hace falta una pieza nueva, -la escribe GEMMA/Operador a mano (ver nota de arquitectura compartida futura, -inbox ME de P200/Fase2). - -**Restricciones heredadas del linaje (no las redescubras):** -- Gobernanza en código, nunca declarada solo en docs. -- El código del organismo vive versionado en el repo, no solo dentro del LXC - (srv-pmox2 es RAID0 sin redundancia). -- Nunca proxy/interceptor de tráfico de modelo, nunca MCP (restricciones - heredadas de P199, D045 §0). - -Presentás el plan de materialización al operador y esperás aprobación antes de ejecutar. - ---- - -## Etapa 3 — Nacimiento por checkpoints (reutiliza el patrón RUBBY/r-WEBs) - -| `STAGE` | Qué nace | Gate de la etapa | -|---------|----------|------------------| -| `esqueleto` | Registro de cuotas + router, con 0 keys cargadas | El router arranca, lee registro vacío, responde "sin datos" ante una consulta de prueba | -| `conexion` | Canal `apids chat` verificado de punta a punta (patrón ya usado con ABBY/MIGUEL/RUBBY/PEGGY) + al menos 1 key real cargada (vía candados, no génesis) | Una consulta real por `apids chat` devuelve el estado correcto de esa key | -| `servicio` | Servicio systemd + `onboot=1` — el organismo revive tras reinicio del hipervisor | El servicio levanta el router solo; sobrevive a un reinicio de la LXC | - -Secrets siempre por env exportado o candados. Al cerrar cada etapa: verificás, -registrás, y esperás OK del operador antes de la siguiente. - ---- - -## Criterio de vida (qué es "nació bien") - -El organismo está vivo cuando, sin intervención: -1. Responde una consulta real de un par (`apids chat`) sobre disponibilidad de - una key/provider, con el dato correcto. -2. Responde explícito y accionable cuando no hay ninguna key disponible (nunca - silencioso). -3. El servicio revive tras un reinicio de la LXC. - -Primer caso real de aplicación (Fase 4 del plan P200): ABBY-F1 consulta a NEXXA -para sus 3 keys de Gemini — no es parte de este nacimiento, es el smoke test -posterior. - ---- - -## individuo.conf (parámetros — el operador completa) - -```conf -# Identidad -NOMBRE=NEXXA # bautizado por el Operador (2026-08-02) — concepto de switch/conmutación -MAQUINA=rm-apid06-nexxa -VMID=(a definir en Fase 3) -IP=(a definir en Fase 3 — requiere aprobación explícita del Operador, nunca se asigna sin OK) -HABITAT=srv-pmox2 - -# Función -PROPOSITO=rotación/fallback de API keys para el equipo F1 — alcance mínimo (no el "sistema circulatorio" amplio de ME-289) - -# Sin Arquitecto — NEXXA no tiene key LLM propia, no genera piezas nuevas por su cuenta -``` - ---- - -## Referencias - -- Delta de dominio: `_docs/RM-LABs/rm-APIDs/D045_diseno-nexxa-f1.md` (dtic-GEMMA) -- Modelo F1 base: `D025_diseno-fundacional-rubby-f1.md` -- Plan: `_docs/RM-LABs/p_P200_*.md` (dtic-GEMMA) -- Precedente de proceso: `rm-apid01-rubby/germen.md` (checkpoints, etapas, gate) -- ME: 289, 292, 293, 330, 331, 335, 417, 468 diff --git a/servicios/nexxa/organismo/VERSION b/servicios/nexxa/organismo/VERSION deleted file mode 100644 index 38f77a65..00000000 --- a/servicios/nexxa/organismo/VERSION +++ /dev/null @@ -1 +0,0 @@ -2.0.1 diff --git a/servicios/nexxa/organismo/chat.rb b/servicios/nexxa/organismo/chat.rb deleted file mode 100644 index 2a9d4ea7..00000000 --- a/servicios/nexxa/organismo/chat.rb +++ /dev/null @@ -1,11 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# chat.rb — Entry point invocado por 'gemma apids chat' (chasis F1 nativo) -# Contrato: recibe el mensaje completo como ARGV[0], imprime texto plano -# (sin LLM, sin JSON — D045 §1/§4, cero semántica en runtime) - -require_relative 'router' - -texto = ARGV[0].to_s -puts Nexxa::Router.procesar(texto) diff --git a/servicios/nexxa/organismo/cli_admin.rb b/servicios/nexxa/organismo/cli_admin.rb deleted file mode 100644 index a7c57faa..00000000 --- a/servicios/nexxa/organismo/cli_admin.rb +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# cli_admin.rb — Bootstrap del primer usuario admin del panel web (P201/Fase4) -# Uso: ruby cli_admin.rb --usuario rmonla (crea, perfil admin) -# ruby cli_admin.rb --usuario rmonla --perfil operador -# ruby cli_admin.rb --usuario rmonla --rotar (rota su password) -# ruby cli_admin.rb --listar (metadata, sin hashes) -# -# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a -# través de GEMMA/candados ni de un agente — la password se imprime UNA vez -# acá y en ningún otro lugar (Regla 15). Una vez que existe al menos un admin, -# el alta de usuarios nuevos se hace normalmente desde el panel (sección -# Usuarios, gateada a perfil admin) — este script es solo para el bootstrap -# inicial o para recuperar acceso si quedan todos los admins bloqueados. - -require_relative 'lib_auth' - -args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] } - -if ARGV.include?('--listar') - usuarios = Nexxa::Auth.listar - if usuarios.empty? - puts 'Sin usuarios todavía.' - else - usuarios.each { |u| puts "#{u['usuario']} (#{u['perfil']}) — #{u['activo'] == false ? 'inactivo' : 'activo'}" } - end - exit -end - -usuario = args['usuario'] -abort 'Uso: ruby cli_admin.rb --usuario [--perfil admin|operador] [--rotar] | --listar' unless usuario - -password = SecureRandom.urlsafe_base64(18) - -if ARGV.include?('--rotar') - Nexxa::Auth.actualizar(usuario: usuario, password_nueva: password) - puts "Password rotada para '#{usuario}'. Nueva password (guardarla ahora, no se vuelve a mostrar):" - puts password -elsif Nexxa::Auth.existe?(usuario) - abort "Usuario '#{usuario}' ya existe — usar --rotar para cambiarle la password." -else - perfil = args['perfil'] || 'admin' - Nexxa::Auth.crear_usuario(usuario: usuario, password: password, perfil: perfil) - puts "Usuario '#{usuario}' creado (perfil #{perfil}). Password (guardarla ahora, no se vuelve a mostrar):" - puts password -end diff --git a/servicios/nexxa/organismo/cli_consumidor.rb b/servicios/nexxa/organismo/cli_consumidor.rb deleted file mode 100644 index 6bdf3b9c..00000000 --- a/servicios/nexxa/organismo/cli_consumidor.rb +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# cli_consumidor.rb — Alta/rotación de token de consumidor sin pasar por el panel (P204) -# Uso: ruby cli_consumidor.rb --individuo gemma (genera/rota token) -# ruby cli_consumidor.rb --listar (metadata, sin hashes) -# ruby cli_consumidor.rb --revocar --individuo gemma (revoca el acceso) -# -# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a -# través de GEMMA/candados ni de un agente — el token se imprime UNA vez acá -# y en ningún otro lugar (Regla 15). - -require_relative 'lib_tokens' - -args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] } - -if ARGV.include?('--listar') - consumidores = Nexxa::Tokens.listar - if consumidores.empty? - puts 'Sin consumidores todavía.' - else - consumidores.each { |c| puts "#{c['individuo']} — creado #{c['creado']}" } - end - exit -end - -individuo = args['individuo'] -abort 'Uso: ruby cli_consumidor.rb --individuo [--revocar] | --listar' unless individuo - -if ARGV.include?('--revocar') - ok = Nexxa::Tokens.revocar(individuo) - puts(ok ? "Acceso revocado para '#{individuo}'." : "'#{individuo}' no tenía token activo.") -else - token = Nexxa::Tokens.generar(individuo) - puts "Token generado para '#{individuo}' (guardarlo ahora, no se vuelve a mostrar):" - puts token -end diff --git a/servicios/nexxa/organismo/cli_estado.rb b/servicios/nexxa/organismo/cli_estado.rb deleted file mode 100644 index 7faf3e0b..00000000 --- a/servicios/nexxa/organismo/cli_estado.rb +++ /dev/null @@ -1,162 +0,0 @@ -# frozen_string_literal: true - -# cli_estado.rb — Mover el estado de NEXXA entre el motor archivo y su Postgres propio (P335/Fase 17) -# ============================================================================== -# Corre EN el nodo, en organismo/, con el usuario del servicio (autenticación peer al Postgres local): -# ruby cli_estado.rb esquema # crea las tablas estado y usos si faltan -# ruby cli_estado.rb migrar # archivos → pg. Respalda los JSON y usos.log en bkp_estado_.tgz antes de -# # escribir. Idempotente: una segunda corrida informa 'igual' en todo y no escribe. -# ruby cli_estado.rb verificar # pg == archivos clave por clave y usos por cantidad; sale 1 si difiere -# ruby cli_estado.rb exportar # pg → archivos: la VUELTA ATRÁS (respaldo previo de lo que haya en disco) -# Independiente de NEXXA_ESTADO: lee y escribe los dos motores explícitamente. Nunca imprime valores, solo claves y -# conteos (el registro tiene los secretos cifrados y usuarios los hashes). -# ============================================================================== - -require 'json' -require 'time' -require_relative 'lib_estado' - -module Nexxa - module CliEstado - E = Nexxa::Estado - USO = 'ruby cli_estado.rb esquema|migrar|verificar|exportar' - # El drop-in que activa el motor pg en los servicios (lo escribe nexxa estado:pg --accion activar) - DROPIN = '/etc/systemd/system/nexxa.service.d/estado.conf' - - module_function - - def call(accion, salida: $stdout) - case accion - when 'esquema' - E.crear_esquema! - salida.puts('✅ tablas estado y usos listas') - 0 - when 'migrar' then migrar(salida) - when 'verificar' then verificar(salida) - when 'exportar' then exportar(salida) - else - salida.puts("Uso: #{USO}") - 2 - end - end - - # Con el motor pg ya activo, los archivos quedaron viejos: migrar pisaría el estado vivo con ellos. Se niega (repetir - # 'activar' es seguro: frena acá y el trap vuelve a arrancar los servicios como estaban). - def pg_activo?(dropin = DROPIN) - File.exist?(dropin) && File.read(dropin).include?('NEXXA_ESTADO=pg') - end - - def migrar(salida, dropin: DROPIN) - if pg_activo?(dropin) - salida.puts("❌ el motor pg ya está activo (#{dropin}): migrar pisaría el estado vivo con archivos viejos. " \ - 'Para volver a archivos: exportar (nexxa estado:pg --accion revertir)') - return 1 - end - - E.crear_esquema! - dif = diferencias - if dif.values.none? - salida.puts('✅ igual: pg ya coincide con los archivos, nada que migrar') - return 0 - end - - salida.puts("🗄 respaldo: #{respaldar}") - E::ARCHIVOS.each_key do |clave| - next salida.puts(" = #{clave}: igual") unless dif[clave] - - E.pg_guardar(clave, E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])) - salida.puts(" → #{clave}: migrada") - end - if dif['usos'] - n_pg = contar_usos_pg - unless n_pg.zero? - salida.puts("❌ usos: pg ya tiene #{n_pg} fila(s) que no coinciden con usos.log (#{usos_archivo.size}); no reimporto para no duplicar") - return 1 - end - # Todo o nada: una carga parcial dejaría la cuenta desigual y migrar ya no podría reintentarse (no reimporta) - E.sincronizado do - E.con.exec('BEGIN') - begin - usos_archivo.each { |u| E.usos_registrar_pg(normalizar_uso(u)) } - E.con.exec('COMMIT') - rescue StandardError - E.con.exec('ROLLBACK') - raise - end - end - salida.puts(" → usos: #{usos_archivo.size} fila(s)") - end - verificar(salida) - end - - def verificar(salida) - dif = diferencias - dif.each { |clave, distinta| salida.puts(" #{distinta ? '≠' : '='} #{clave}") } - if dif.values.any? - salida.puts("❌ pg difiere de los archivos en: #{dif.select { |_, d| d }.keys.join(', ')}") - 1 - else - salida.puts("✅ pg coincide con los archivos (#{E::ARCHIVOS.size} claves, #{contar_usos_pg} usos)") - 0 - end - end - - def exportar(salida) - salida.puts("🗄 respaldo de lo que había en disco: #{respaldar}") - E::ARCHIVOS.each_key do |clave| - fila = E.sincronizado { E.con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first } - next salida.puts(" · #{clave}: no está en pg, el archivo queda como estaba") unless fila - - E.archivo_guardar(E.ruta(clave), JSON.parse(fila['valor'])) - salida.puts(" ← #{clave}") - end - usos = E.sincronizado { E.con.exec('SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos ORDER BY id').to_a } - File.open("#{E::USOS_LOG}.tmp", 'w', 0o600) do |f| - usos.each { |u| f.puts(E.normalizar_uso(u).to_json) } - end - File.rename("#{E::USOS_LOG}.tmp", E::USOS_LOG) - salida.puts(" ← usos: #{usos.size} fila(s)") - verificar(salida) - end - - # { clave => true si pg difiere del archivo, ..., 'usos' => true si la cantidad difiere } - def diferencias - d = E::ARCHIVOS.keys.to_h do |clave| - [clave, E.pg_leer(clave, nil) != E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])] - end - d.merge('usos' => contar_usos_pg != usos_archivo.size) - end - - # Líneas viejas de usos.log (anteriores a P204/Fase 3) no traen 'evento': eran todas dispensas (contrato de - # Nexxa::Usos). Sin esto la columna NOT NULL frenó la primera activación real (2026-10-05 02:43). - def normalizar_uso(u) - u.merge('evento' => u['evento'] || 'dispensada', 'individuo' => u['individuo'], 'en' => u['en'] || Time.at(0).iso8601) - end - - def contar_usos_pg - E.sincronizado { E.con.exec('SELECT count(*) AS n FROM usos').first['n'].to_i } - end - - def usos_archivo - @usos_archivo ||= begin - return [] unless File.exist?(E::USOS_LOG) - - File.readlines(E::USOS_LOG).filter_map do |l| - JSON.parse(l) - rescue JSON::ParserError - nil - end - end - end - - def respaldar - archivos = (E::ARCHIVOS.values + ['usos.log']).select { |a| File.exist?(File.join(E::DIR, a)) } - tgz = File.join(E::DIR, "bkp_estado_#{Time.now.strftime('%Y%m%d%H%M%S')}.tgz") - system('tar', 'czf', tgz, '-C', E::DIR, *archivos, exception: true) unless archivos.empty? - File.chmod(0o600, tgz) if File.exist?(tgz) - archivos.empty? ? 'sin archivos que respaldar' : tgz - end - end -end - -exit Nexxa::CliEstado.call(ARGV.first) if $PROGRAM_NAME == __FILE__ diff --git a/servicios/nexxa/organismo/cli_registrar.rb b/servicios/nexxa/organismo/cli_registrar.rb deleted file mode 100644 index ed599c52..00000000 --- a/servicios/nexxa/organismo/cli_registrar.rb +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# cli_registrar.rb — Alta de una key con su valor real (D045 §10/§11, P201/Fase2-3) -# Uso: ruby cli_registrar.rb -# (el valor real se lee por STDIN, nunca por argv — ME-293/296) -# -# echo -n "$VALOR" | ruby cli_registrar.rb gemini gemini-01 abby 86400 -# -# cuenta_origen: cuenta ante el proveedor que generó esta key — PERMANENTE, -# informativo, no filtro de acceso (D045 §11 — distinto de "quién la tiene -# asignada ahora", eso es ultimo_individuo/marcar_uso, efímero). -# -# NEXXA aloja ella misma el valor real, cifrado en su storage propio (D045 §10 -# — reemplaza a candados como lugar de guarda de API keys de terceros). El -# valor nunca pasa por argv/log — solo por STDIN, mismo patrón ya usado por -# GEMMA para credenciales (ME-116). - -require_relative 'lib_registro' - -provider, identificador, cuenta_origen, reset_segundos = ARGV -unless provider && identificador && cuenta_origen && reset_segundos - abort 'Uso: echo -n "$VALOR" | cli_registrar.rb ' -end - -valor = $stdin.read.strip -abort 'Valor vacío por STDIN' if valor.empty? - -Nexxa::Registro.registrar( - provider: provider, - identificador: identificador, - cuenta_origen: cuenta_origen, - reset_segundos: reset_segundos.to_i, - valor: valor, - por: 'cli' # queda en el registro de usos (P337/Fase 1) -) - -puts "Registrado: #{provider} → #{identificador} (cuenta: #{cuenta_origen})" diff --git a/servicios/nexxa/organismo/latido.rb b/servicios/nexxa/organismo/latido.rb deleted file mode 100644 index fafaa48d..00000000 --- a/servicios/nexxa/organismo/latido.rb +++ /dev/null @@ -1,20 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# latido.rb — Heartbeat mínimo, mantiene vivo el proceso del servicio -# ============================================================================== -# NEXXA-F1 (P200) responde a consultas puntuales vía apids chat (SSH bajo -# demanda, sin loop de decisión propio — D045 §1/§4). Este latido NO procesa -# estímulos ni carrera de era (a diferencia de RUBBY/PEGGY) — su único rol es -# marcar 'el organismo está vivo' para el criterio de vida (revive tras -# reinicio de la LXC) y dejar un heartbeat auditable en log, cadencia 300s -# (ME-435: latido ≠ conversar, nunca comparte proceso con el canal directo). -# ============================================================================== - -LOG_FILE = File.expand_path('latido.log', __dir__) -CADENCIA_SEGUNDOS = 300 - -loop do - File.open(LOG_FILE, 'a') { |f| f.puts("#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} — vivo") } - sleep CADENCIA_SEGUNDOS -end diff --git a/servicios/nexxa/organismo/lib_auth.rb b/servicios/nexxa/organismo/lib_auth.rb deleted file mode 100644 index 46973d5b..00000000 --- a/servicios/nexxa/organismo/lib_auth.rb +++ /dev/null @@ -1,201 +0,0 @@ -# frozen_string_literal: true - -# lib_auth.rb — Usuarios y sesiones del panel web de NEXXA (P201/Fase4) -# ============================================================================== -# Reemplaza el diseño original (nginx Basic Auth + credencial en candados de -# GEMMA) por corrección explícita del Operador: NEXXA resuelve su propia auth, -# sin dependencia de GEMMA — mismo espíritu de independencia que ya tienen -# lib_tokens.rb (individuos F1) y lib_cripto.rb (master key propia). -# -# Multi-usuario con perfil (corrección 2026-08-03 — el diseño original de un -# solo Operador binario no alcanzaba, el Operador pidió CRUD de usuarios real, -# gateado por perfil): dos perfiles, sin inventar granularidad no pedida — -# - 'admin' → todo, incluida la gestión de usuarios (crear/editar/borrar) -# - 'operador' → todo lo demás (keys, consumidores), sin gestión de usuarios -# -# No reinventa primitivas de seguridad (pedido explícito del Operador): usa -# exactamente el mismo algoritmo ya probado en producción en -# gemma/tools/candados/core/lib_cripto.rb (Armonía Integral) — PBKDF2-HMAC-SHA256, -# 100k iteraciones, salt random — en vez de SHA256 plano (adecuado para el -# token aleatorio de lib_tokens.rb, pero no para una password humana). -# -# Sesión: token aleatorio de alta entropía (mismo patrón que Tokens.generar), -# guardado server-side con expiración, entregado como cookie. HttpOnly/Secure/ -# SameSite se arman a mano en el header Set-Cookie (server.rb) porque el -# WEBrick::Cookie de esta versión de Ruby no expone esos atributos — ver -# comentario en server.rb. -# ============================================================================== - -require 'json' -require 'securerandom' -require 'openssl' -require 'base64' -require 'time' -require_relative 'lib_estado' - -module Nexxa - module Auth - USERS_FILE = Estado.ruta('usuarios') - SESSIONS_FILE = Estado.ruta('sesiones') - PBKDF2_ITER = 100_000 - SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable - PERFILES_VALIDOS = %w[admin operador].freeze - - # ---------- Usuarios ---------- - - # Estado vía Nexxa::Estado (P335/Fase 17) - def self.leer_usuarios - Estado.leer('usuarios', USERS_FILE, []) - end - - def self.guardar_usuarios(lista) - Estado.guardar('usuarios', USERS_FILE, lista) - end - - def self.derivar(password, salt) - OpenSSL::PKCS5.pbkdf2_hmac(password, salt, PBKDF2_ITER, 32, 'SHA256') - end - - # Crea un usuario nuevo — devuelve la password EN CLARO solo si el - # caller la generó (bootstrap por cli_admin.rb), o la recibe ya elegida - # (alta vía panel por un admin). Nunca se persiste ni se loguea en claro. - # raise si el usuario ya existe o el perfil no es válido. - def self.crear_usuario(usuario:, password:, perfil:) - usuario = usuario.to_s.strip - raise 'Usuario vacío' if usuario.empty? - raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil) - - Estado.mutar('usuarios', USERS_FILE, []) do |lista| - raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario } - - salt = SecureRandom.random_bytes(16) - hash = derivar(password, salt) - lista << { - 'usuario' => usuario, - 'perfil' => perfil, - 'salt' => Base64.strict_encode64(salt), - 'hash' => Base64.strict_encode64(hash), - 'activo' => true, - 'creado' => Time.now.iso8601 - } - lista - end - usuario - end - - # Verifica usuario+password — devuelve el registro (sin salt/hash) si es - # válido y está activo, nil si no. Comparación de tiempo constante. - def self.autenticar(usuario:, password:) - entrada = leer_usuarios.find { |u| u['usuario'] == usuario.to_s.strip && u['activo'] != false } - return nil unless entrada - - salt = Base64.strict_decode64(entrada['salt']) - hash_guardado = Base64.strict_decode64(entrada['hash']) - hash_calculado = derivar(password.to_s, salt) - return nil unless hash_guardado.bytesize == hash_calculado.bytesize && - OpenSSL.fixed_length_secure_compare(hash_guardado, hash_calculado) - - entrada.reject { |k, _| %w[salt hash].include?(k) } - end - - # Todos los usuarios, solo metadata — NUNCA salt/hash (Regla 15). - def self.listar - leer_usuarios.map { |u| u.reject { |k, _| %w[salt hash].include?(k) } } - end - - def self.existe?(usuario) - leer_usuarios.any? { |u| u['usuario'] == usuario.to_s.strip } - end - - # Edita perfil/activo de un usuario existente. password_nueva opcional - # (rotación). raise si no existe o el perfil no es válido. - def self.actualizar(usuario:, perfil: nil, activo: nil, password_nueva: nil) - entrada = nil - Estado.mutar('usuarios', USERS_FILE, []) do |lista| - entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip } - raise "Usuario '#{usuario}' no encontrado" unless entrada - - if perfil - raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil) - entrada['perfil'] = perfil - end - entrada['activo'] = activo unless activo.nil? - if password_nueva && !password_nueva.to_s.strip.empty? - salt = SecureRandom.random_bytes(16) - entrada['salt'] = Base64.strict_encode64(salt) - entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt)) - end - lista - end - entrada.reject { |k, _| %w[salt hash].include?(k) } - end - - # Elimina un usuario — destructivo. El caller (server.rb) es responsable - # de impedir que el último admin se borre a sí mismo (guardia de negocio, - # no de esta capa de datos). - def self.eliminar(usuario) - existia = nil - Estado.mutar('usuarios', USERS_FILE, []) do |lista| - existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip } - lista - end - !existia.nil? - end - - def self.admins_activos - leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false } - end - - # ---------- Sesiones ---------- - - def self.leer_sesiones - Estado.leer('sesiones', SESSIONS_FILE, {}) - end - - def self.guardar_sesiones(sesiones) - Estado.guardar('sesiones', SESSIONS_FILE, sesiones) - end - - def self.crear_sesion(usuario, perfil) - token = SecureRandom.hex(32) - Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones| - sesiones[token] = { - 'usuario' => usuario, - 'perfil' => perfil, - 'expira' => (Time.now + SESSION_TTL).iso8601 - } - sesiones - end - token - end - - # Devuelve {usuario, perfil} de la sesión si es válida, nil si no. - def self.sesion(token) - return nil if token.to_s.strip.empty? - - entrada = leer_sesiones[token] - return nil unless entrada - - # Vencida: se borra con la escritura atómica de cerrar_sesion (la lectura de cada pedido web no toma bloqueo) - if Time.parse(entrada['expira']) < Time.now - cerrar_sesion(token) - return nil - end - - { 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] } - end - - def self.sesion_valida?(token) - !sesion(token).nil? - end - - def self.cerrar_sesion(token) - existia = nil - Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones| - existia = sesiones.delete(token) - sesiones - end - !existia.nil? - end - end -end diff --git a/servicios/nexxa/organismo/lib_checkins.rb b/servicios/nexxa/organismo/lib_checkins.rb deleted file mode 100644 index b2f3ecd3..00000000 --- a/servicios/nexxa/organismo/lib_checkins.rb +++ /dev/null @@ -1,56 +0,0 @@ -# frozen_string_literal: true - -# lib_checkins.rb — Reporte proactivo de estado de individuos F1 (P216) -# ============================================================================== -# Complementa lib_tokens.rb (identidad) con un registro simple de "qué contó cada -# individuo de sí mismo la última vez" — mismo espíritu que Registro.disponible -# para keys: NEXXA solo guarda lo que le reportan, nunca sale a diagnosticar -# nada por su cuenta. Quien consulta (GEMMA, vía bandeja.rb) decide qué hacer -# con la antigüedad del último reporte. -# ============================================================================== - -require 'json' -require 'time' -require_relative 'lib_estado' - -module Nexxa - module Checkins - STATE_FILE = Estado.ruta('checkins') - - # Estado vía Nexxa::Estado (P335/Fase 17) - def self.leer - Estado.leer('checkins', STATE_FILE, {}) - end - - def self.guardar(state) - Estado.guardar('checkins', STATE_FILE, state) - end - - def self.mutar(&) - Estado.mutar('checkins', STATE_FILE, {}, &) - end - - # El individuo llega autenticado (individuo_autenticado(req) en server.rb, - # vía Nexxa::Tokens.verificar) — nunca confiar en un id que venga en el - # body, el token YA identifica quién reporta. - def self.registrar(individuo, estado:, detalle: nil) - mutar do |state| - state[individuo] = { - 'estado' => estado.to_s, - 'detalle' => detalle, - 'ultimo_reporte' => Time.now.utc.iso8601 - } - state - end - state[individuo] - end - - def self.estado(individuo) - leer[individuo] - end - - def self.listar - leer - end - end -end diff --git a/servicios/nexxa/organismo/lib_cripto.rb b/servicios/nexxa/organismo/lib_cripto.rb deleted file mode 100644 index e4ae8d70..00000000 --- a/servicios/nexxa/organismo/lib_cripto.rb +++ /dev/null @@ -1,74 +0,0 @@ -# frozen_string_literal: true - -# lib_cripto.rb — Motor criptográfico AES-256-GCM, adaptado de gemma/tools/candados/core/lib_cripto.rb -# ============================================================================== -# NEXXA-F1 (P201/Fase2) — mismo algoritmo que la bóveda de candados de GEMMA -# (Armonía Integral, no reinventar), pero SIN derivación por frase humana: NEXXA -# cifra/descifra 24/7 sin intervención (D045 §10, storage propio de la key real). -# La master key vive en un archivo local (MasterKey.cargar!), nunca en argv/log. -# ============================================================================== - -require 'openssl' -require 'base64' -require 'json' -require 'securerandom' - -module Nexxa - class Cripto - ALGORITHM = 'aes-256-gcm' - - def initialize(key_bytes) - raise 'Master key debe tener 32 bytes (256 bits)' unless key_bytes.bytesize == 32 - - @key = key_bytes - end - - def encrypt(plaintext) - cipher = OpenSSL::Cipher.new(ALGORITHM) - cipher.encrypt - cipher.key = @key - iv = cipher.random_iv - ciphertext = cipher.update(plaintext.to_s) + cipher.final - payload = { iv: b64(iv), tag: b64(cipher.auth_tag), data: b64(ciphertext) } - Base64.strict_encode64(payload.to_json) - end - - def decrypt(token) - p = JSON.parse(Base64.strict_decode64(token), symbolize_names: true) - cipher = OpenSSL::Cipher.new(ALGORITHM) - cipher.decrypt - cipher.key = @key - cipher.iv = db64(p[:iv]) - cipher.auth_tag = db64(p[:tag]) - cipher.update(db64(p[:data])) + cipher.final - rescue StandardError => e - raise "Error al descifrar: #{e.message}" - end - - private - - def b64(d) = Base64.strict_encode64(d) - def db64(d) = Base64.strict_decode64(d) - end - - module MasterKey - RUTA = File.expand_path('.master_key', __dir__) - - # Genera la master key UNA VEZ (idempotente — si ya existe, no la toca). - # Devuelve los bytes en ambos casos. El caller decide si hace backup (candados). - def self.generar_si_falta! - return File.binread(RUTA) if File.exist?(RUTA) - - bytes = SecureRandom.random_bytes(32) - File.binwrite(RUTA, bytes) - File.chmod(0o600, RUTA) - bytes - end - - def self.cargar! - raise "Master key no existe en #{RUTA} — correr MasterKey.generar_si_falta! primero" unless File.exist?(RUTA) - - File.binread(RUTA) - end - end -end diff --git a/servicios/nexxa/organismo/lib_envelope.rb b/servicios/nexxa/organismo/lib_envelope.rb deleted file mode 100644 index 1b3a74ce..00000000 --- a/servicios/nexxa/organismo/lib_envelope.rb +++ /dev/null @@ -1,38 +0,0 @@ -# frozen_string_literal: true - -# lib_envelope.rb — Cifrado de punta a punta hacia el consumidor (P204, "Aplica -# Pilares" sobre la decisión previa de diferirlo) -# ============================================================================== -# Distinto de lib_cripto.rb (AES simétrico, master key propia de NEXXA, cifra EN -# REPOSO — lo que NEXXA guarda). Esto es asimétrico (RSA-OAEP), cifra PARA EL -# CONSUMIDOR — ni NEXXA ni nadie que capture el cuerpo de la respuesta HTTP -# puede leer el valor sin la clave PRIVADA del individuo, que NUNCA sale de -# ese individuo (NEXXA solo guarda la pública, ver lib_tokens.rb). -# -# RSA-OAEP directo (sin AES intermedio): las API keys son strings cortos -# (~30-60 bytes) — un RSA de 2048 bits con padding OAEP-SHA256 cifra hasta -# ~190 bytes de una, de sobra. No hace falta el patrón "envelope" clásico -# (RSA cifra una clave AES efímera, AES cifra el payload grande) porque acá -# el payload YA es chico — agregar esa capa sería complejidad sin beneficio -# real (Menos es Más). -# ============================================================================== - -require 'openssl' -require 'base64' - -module Nexxa - module Envelope - # Cifra `valor` con la clave pública PEM del consumidor — devuelve base64, - # listo para meter en un campo JSON de la respuesta HTTP. Nunca falla en - # silencio: una clave pública inválida hace que esto reviente (server.rb - # decide qué hacer, no lo traga acá). - def self.cifrar_para(clave_publica_pem, valor) - rsa = OpenSSL::PKey::RSA.new(clave_publica_pem) - Base64.strict_encode64(rsa.public_encrypt(valor.to_s, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)) - end - - # Deliberadamente NO hay Envelope.descifrar acá — descifrar es trabajo - # del CONSUMIDOR con su propia clave privada, nunca de NEXXA. Si NEXXA - # pudiera descifrar esto, no sería de punta a punta. - end -end diff --git a/servicios/nexxa/organismo/lib_estado.rb b/servicios/nexxa/organismo/lib_estado.rb deleted file mode 100644 index d3d144ef..00000000 --- a/servicios/nexxa/organismo/lib_estado.rb +++ /dev/null @@ -1,223 +0,0 @@ -# frozen_string_literal: true - -# lib_estado.rb — Único punto de acceso al estado de NEXXA (P335/Fase 17, REG002 R15) -# ============================================================================== -# registro, tokens, pools, checkins, usuarios y sesiones (blobs JSON) y el log de usos pasan por acá. Dos motores: -# archivo — el de siempre: un JSON 0600 junto al código por clave (escritura atómica tmp+rename) y usos.log JSONL. -# pg — Postgres PROPIO de srvv-nexxa (decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8 -# caiga). Tablas estado (clave, valor jsonb) y usos. Socket local con autenticación peer: el usuario del -# servicio es el rol, sin contraseña que guardar. -# El motor se elige EXPLÍCITO con NEXXA_ESTADO=pg (drop-in systemd de los dos servicios); sin la variable, archivo. -# Nunca cae solo de pg a archivo: nexxa-http y nexxa con motores distintos partirían el estado en dos. -# -# mutar(clave) { |v| ...; v } es leer-modificar-guardar ATÓMICO: SELECT ... FOR UPDATE en una transacción (pg) o -# flock exclusivo (archivo). Antes los dos servicios leían, modificaban y guardaban el mismo archivo sin bloqueo. -# ============================================================================== - -require 'json' -require 'monitor' -require 'time' - -module Nexxa - module Estado - MOTORES = %w[archivo pg].freeze - DIR = __dir__ - USOS_LOG = File.join(__dir__, 'usos.log').freeze - MONITOR = Monitor.new - # Fuente única clave → archivo del motor archivo (los libs toman su STATE_FILE de acá y cli_estado recorre esto) - ARCHIVOS = { - 'registro' => 'registro.json', 'tokens' => 'tokens.json', 'pools' => 'pools.json', - 'checkins' => 'checkins.json', 'usuarios' => '.usuarios.json', 'sesiones' => '.sessions.json' - }.freeze - DEFECTOS = { - 'registro' => { 'keys' => [] }, 'tokens' => { 'tokens' => [] }, 'pools' => { 'individuos' => {} }, - 'checkins' => {}, 'usuarios' => [], 'sesiones' => {} - }.freeze - - module_function - - def motor - m = ENV.fetch('NEXXA_ESTADO', 'archivo') - raise ArgumentError, "NEXXA_ESTADO=#{m} inválido (#{MOTORES.join('|')})" unless MOTORES.include?(m) - - m - end - - def pg? - motor == 'pg' - end - - def ruta(clave) - File.join(DIR, ARCHIVOS.fetch(clave)) - end - - # archivo: ruta del JSON de esa clave (el mismo nombre que tenía antes de esta capa) - def leer(clave, archivo, defecto) - pg? ? pg_leer(clave, defecto) : archivo_leer(archivo, defecto) - end - - def guardar(clave, archivo, valor) - pg? ? pg_guardar(clave, valor) : archivo_guardar(archivo, valor) - valor - end - - def mutar(clave, archivo, defecto) - if pg? - # BEGIN/COMMIT a mano con ensure: un error o un 'return' dentro del bloque (salida no local) hacen ROLLBACK y - # nunca dejan la conexión a mitad de una transacción. Igual que el motor archivo: sin salida normal no se guarda. - # Los bloques no usan 'return'. - sincronizado do - con.exec('BEGIN') - begin - con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ON CONFLICT (clave) DO NOTHING', - [clave, JSON.generate(defecto)]) - fila = con.exec_params('SELECT valor FROM estado WHERE clave = $1 FOR UPDATE', [clave]).first - nuevo = yield(JSON.parse(fila['valor'])) - con.exec_params('UPDATE estado SET valor = $2::jsonb, actualizado_en = NOW() WHERE clave = $1', [clave, JSON.generate(nuevo)]) - nuevo - rescue Exception # rubocop:disable Lint/RescueException -- todo error deshace y se re-lanza - con.exec('ROLLBACK') - raise - else - con.exec('COMMIT') - nuevo - ensure - con.exec('ROLLBACK') unless con.transaction_status.zero? # 0 = PQTRANS_IDLE - end - end - else - File.open("#{archivo}.lock", File::RDWR | File::CREAT, 0o600) do |l| - l.flock(File::LOCK_EX) - nuevo = yield(archivo_leer(archivo, defecto)) - archivo_guardar(archivo, nuevo) - nuevo - end - end - end - - # ---------- usos (append-only) ---------- - - def usos_registrar(linea) - pg? ? usos_registrar_pg(linea) : File.open(USOS_LOG, 'a') { |f| f.puts(linea.to_json) } - end - - def usos_registrar_pg(linea) - sincronizado do - con.exec_params('INSERT INTO usos (provider, identificador, individuo, evento, en, motivo, hasta) ' \ - 'VALUES ($1, $2, $3, $4, $5, $6, $7)', - linea.values_at('provider', 'identificador', 'individuo', 'evento', 'en', 'motivo', 'hasta')) - end - end - - FILTROS_USOS = %w[provider identificador individuo evento].freeze - - # Más reciente primero. Filtros exactos por campo y 'desde' (Time) para una ventana (P337/Fase 1) - def usos_historial(provider: nil, identificador: nil, individuo: nil, evento: nil, desde: nil, limit: 100) - f = { 'provider' => provider, 'identificador' => identificador, 'individuo' => individuo, 'evento' => evento } - return usos_archivo(f, desde, limit) unless pg? - - sincronizado do - con.exec_params(<<~SQL, f.values_at(*FILTROS_USOS) + [desde&.iso8601, limit]).map { |u| normalizar_uso(u) } - SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos - WHERE ($1::text IS NULL OR provider = $1) AND ($2::text IS NULL OR identificador = $2) - AND ($3::text IS NULL OR individuo = $3) AND ($4::text IS NULL OR evento = $4) - AND ($5::timestamptz IS NULL OR en >= $5) - ORDER BY id DESC LIMIT $6 - SQL - end - end - - # Fechas en ISO 8601 con zona, igual en los dos motores - def normalizar_uso(u) - u.merge('en' => Time.parse(u['en'].to_s).iso8601, 'hasta' => u['hasta'] && Time.parse(u['hasta'].to_s).iso8601(3), - 'motivo' => u['motivo']) - end - - # ---------- motor archivo ---------- - - def archivo_leer(archivo, defecto) - return defecto unless File.exist?(archivo) - - JSON.parse(File.read(archivo, encoding: 'UTF-8')) - rescue JSON::ParserError - defecto - end - - def archivo_guardar(archivo, valor) - tmp = "#{archivo}.tmp-#{Process.pid}-#{Thread.current.object_id}" - File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(valor) + "\n") } - File.rename(tmp, archivo) - end - - def usos_archivo(filtros, desde, limit) - return [] unless File.exist?(USOS_LOG) - - lineas = File.readlines(USOS_LOG, encoding: 'UTF-8').filter_map do |l| # locale C del servicio (ME-1216) - JSON.parse(l) - rescue JSON::ParserError - nil - end - filtros.each { |campo, valor| lineas.select! { |l| l[campo] == valor } if valor } - lineas.select! { |l| l['en'] && Time.parse(l['en']) >= desde } if desde - lineas.last(limit).reverse.map { |u| normalizar_uso(u) } - end - - # ---------- motor pg ---------- - - def pg_leer(clave, defecto) - fila = sincronizado { con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first } - fila ? JSON.parse(fila['valor']) : defecto - end - - def pg_guardar(clave, valor) - sincronizado do - con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ' \ - 'ON CONFLICT (clave) DO UPDATE SET valor = EXCLUDED.valor, actualizado_en = NOW()', - [clave, JSON.generate(valor)]) - end - end - - ESQUEMA = <<~SQL - CREATE TABLE IF NOT EXISTS estado ( - clave TEXT PRIMARY KEY, - valor JSONB NOT NULL, - actualizado_en TIMESTAMPTZ NOT NULL DEFAULT NOW() - ); - CREATE TABLE IF NOT EXISTS usos ( - id BIGSERIAL PRIMARY KEY, - provider TEXT NOT NULL, - identificador TEXT NOT NULL, - individuo TEXT, - evento TEXT NOT NULL, - en TIMESTAMPTZ NOT NULL - ); - CREATE INDEX IF NOT EXISTS usos_key ON usos (provider, identificador); - ALTER TABLE usos ADD COLUMN IF NOT EXISTS motivo TEXT; - ALTER TABLE usos ADD COLUMN IF NOT EXISTS hasta TIMESTAMPTZ; - CREATE INDEX IF NOT EXISTS usos_en ON usos (en); - SQL - - def crear_esquema! - sincronizado { con.exec(ESQUEMA) } - end - - # Conexión única por proceso (inyectable en tests). Monitor reentrante: WEBrick atiende en varios hilos y un bloque - # de mutar puede llamar a otra operación de Estado. - def con - @con ||= begin - require 'pg' - c = PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa')) - c.exec(ESQUEMA) # idempotente: un despliegue que amplía el esquema se aplica solo al arrancar (P337/Fase 1) - c - end - end - - def con=(otra) - @con = otra - end - - def sincronizado(&) - MONITOR.synchronize(&) - end - end -end diff --git a/servicios/nexxa/organismo/lib_pools.rb b/servicios/nexxa/organismo/lib_pools.rb deleted file mode 100644 index 57037dca..00000000 --- a/servicios/nexxa/organismo/lib_pools.rb +++ /dev/null @@ -1,220 +0,0 @@ -# frozen_string_literal: true - -# lib_pools.rb — Pools de keys POR INDIVIDUO: mente y red de seguridad (P335/Fase 4, Operador 2026-10-04) -# -# Cada individuo tiene dos pools: MENTE (las keys con las que piensa y opera) y RED (solo para el aviso de batería -# baja). Un pool MEZCLA proveedores y una key puede estar en varios pools (exclusiva o compartida). Es el TERCER eje de -# una key (ME-609): `cuenta_origen` dice quién la aportó (permanente, informativo), `reservado_por` quién la tiene AHORA -# (efímero) y la asignación a pools es CONFIGURACIÓN permanente que decide un admin desde nexxa-web. -# -# Persistencia: pools.json junto a registro.json (0600). NEXXA guarda todo su estado en JSON en su hábitat y no tiene -# Postgres (REG002 R15 lo pide justificar: un individuo sin BD propia; migrarlo a BD es otra decisión). Separado de -# registro.json a propósito: lo que se edita a mano desde la web (config) no se mezcla con el estado vivo de cada key. -# -# Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json). - -require 'json' -require_relative 'lib_estado' - -module Nexxa - module Pools - STATE_FILE = Estado.ruta('pools') - ROLES = %w[mente red].freeze - - module_function - - # Estado vía Nexxa::Estado (P335/Fase 17) - def leer - d = Estado.leer('pools', STATE_FILE, { 'individuos' => {} }) - d['individuos'] ||= {} - d - end - - def guardar(state) - Estado.guardar('pools', STATE_FILE, state) - end - - def mutar - Estado.mutar('pools', STATE_FILE, { 'individuos' => {} }) do |d| - d['individuos'] ||= {} - yield d - end - end - - def ref(provider, identificador) - "#{provider}/#{identificador}" - end - - # Refs del pool de un individuo para un rol. => ["gemini/abby", "deepseek/deepseek-01", ...] - def refs(individuo, rol) - Array(leer.dig('individuos', individuo.to_s, rol.to_s)) - end - - # Asigna una key al pool. Idempotente. Valida rol y que la key exista en el registro (inyectable para tests). - def asignar(individuo:, rol:, provider:, identificador:, existe: nil) - validar!(individuo, rol) - existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } } - raise "Key no encontrada: #{ref(provider, identificador)}" unless existe.call(provider, identificador) - - pool = nil - mutar do |state| - pool = (state['individuos'][individuo] ||= {})[rol] ||= [] - r = ref(provider, identificador) - pool << r unless pool.include?(r) - state - end - pool - end - - # Quita una key de un pool. => true si estaba. - def quitar(individuo:, rol:, provider:, identificador:) - validar!(individuo, rol) - quitado = nil - mutar do |state| - pool = state.dig('individuos', individuo, rol) - quitado = pool&.delete(ref(provider, identificador)) - if quitado - state['individuos'][individuo].delete(rol) if pool.empty? - state['individuos'].delete(individuo) if state['individuos'][individuo].empty? - end - state - end - !quitado.nil? - end - - # Deja el pool EXACTAMENTE con estas refs (editar desde nexxa-web, P335/Fase 12). Valida todas antes de escribir: - # una sola inválida y no se toca nada. Lista vacía = vaciar el pool. => refs finales - def reemplazar(individuo:, rol:, refs:, existe: nil) - validar!(individuo, rol) - existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } } - refs = Array(refs).map(&:to_s).uniq - malas = refs.reject { |r| (p, i = r.split('/', 2)) && i && existe.call(p, i) } - raise "Key(s) no encontrada(s): #{malas.join(', ')}" unless malas.empty? - - mutar do |state| - roles = (state['individuos'][individuo] ||= {}) - refs.empty? ? roles.delete(rol) : roles[rol] = refs - state['individuos'].delete(individuo) if roles.empty? - state - end - refs - end - - # Pasa una key del rol 'de' al otro rol del mismo individuo, en una sola escritura. => rol destino - def mover(individuo:, de:, provider:, identificador:) - validar!(individuo, de) - a = (ROLES - [de.to_s]).first - r = ref(provider, identificador) - mutar do |state| - roles = state.dig('individuos', individuo) - raise "#{r} no está en #{individuo}/#{de}" unless roles && Array(roles[de]).include?(r) - - roles[de].delete(r) - roles.delete(de) if roles[de].empty? - (roles[a] ||= []) << r unless Array(roles[a]).include?(r) - state - end - a - end - - # Al renombrar una key, sus refs en todos los pools pasan al nombre nuevo (P335/Fase 13) - def renombrar_key(provider:, de:, a:) - cambio = nil - mutar do |state| - viejo = ref(provider, de) - nuevo = ref(provider, a) - cambio = false - state['individuos'].each_value do |roles| - roles.each_value { |pool| (i = pool.index(viejo)) && (pool[i] = nuevo) && (cambio = true) } - end - state - end - cambio - end - - # Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas). - def olvidar_key(provider:, identificador:) - cambio = nil - mutar do |state| - r = ref(provider, identificador) - cambio = false - state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } } - state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } } - state['individuos'].delete_if { |_, roles| roles.empty? } - state - end - cambio - end - - # Al revocar un individuo (sin token ya no puede pedir) sus pools se borran: sin referencias colgadas (P335/F12) - def olvidar_individuo(individuo) - borrado = nil - mutar do |state| - borrado = state['individuos'].delete(individuo.to_s) - state - end - !borrado.nil? - end - - # Resumen por rol para la sección Individuos y el Dashboard: { 'mente' => {'total'=>, 'disponibles'=>}, ... } - def resumen(individuo) - ROLES.to_h do |rol| - filas = Nexxa::Registro.estado_en(refs(individuo, rol)) - [rol, { 'total' => filas.size, 'disponibles' => filas.count { |f| f['estado'] == 'disponible' } }] - end - end - - # Pools en los que está una key. => [{ 'individuo' =>, 'rol' => }] - def de_key(provider, identificador, state = leer) - r = ref(provider, identificador) - state['individuos'].flat_map do |ind, roles| - roles.select { |_, pool| pool.include?(r) }.map { |rol, _| { 'individuo' => ind, 'rol' => rol } } - end - end - - # --- Selección por NOMBRE (P335/Fase 5): el único lugar que decide si /disponible/ es un rol o un provider. - # Rol (mente|red) → el pool del individuo; si está vacío NO cae al provider (respuesta explícita 'pool_vacio'). - # Otro nombre → un provider, como antes (compatibilidad con los consumidores actuales). - def rol?(nombre) - ROLES.include?(nombre.to_s) - end - - def pool_vacio?(individuo, nombre) - rol?(nombre) && refs(individuo, nombre).empty? - end - - def disponible(individuo, nombre) - rol?(nombre) ? Nexxa::Registro.disponible_en(refs(individuo, nombre)) : Nexxa::Registro.disponible(nombre) - end - - # Elegir y reservar la key en UN paso atómico (P335/Fase 17): mismo criterio de candidatas que disponible. - # => entrada reservada, entrada solo-metadata sin reservar (sin valor_cifrado) o nil si no hay libre. - def dispensar(individuo, nombre) - if rol?(nombre) - Nexxa::Registro.reservar_libre(individuo: individuo, refs: refs(individuo, nombre)) - else - Nexxa::Registro.reservar_libre(individuo: individuo, provider: nombre) - end - end - - def proxima(individuo, nombre) - rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre) - end - - def estado(individuo, nombre) - rol?(nombre) ? Nexxa::Registro.estado_en(refs(individuo, nombre)) : Nexxa::Registro.estado_pool(nombre) - end - - # Pools completos con el estado de cada key, para nexxa-web. Nunca valores. - def con_estado - leer['individuos'].transform_values do |roles| - roles.to_h { |rol, pool| [rol, Nexxa::Registro.estado_en(pool)] } - end - end - - def validar!(individuo, rol) - raise 'Falta el individuo' if individuo.to_s.strip.empty? - raise "rol inválido: #{rol} (esperado: #{ROLES.join('|')})" unless ROLES.include?(rol.to_s) - end - end -end diff --git a/servicios/nexxa/organismo/lib_registro.rb b/servicios/nexxa/organismo/lib_registro.rb deleted file mode 100644 index 0403d324..00000000 --- a/servicios/nexxa/organismo/lib_registro.rb +++ /dev/null @@ -1,452 +0,0 @@ -# frozen_string_literal: true - -# lib_registro.rb — Fuente de verdad de cuotas Y del valor real de cada key -# ============================================================================== -# NEXXA-F1 (P200, evolucionado en P201/Fase2-3 — D045 §10/§11) — registro propio, -# inspirado en apirot.rb (P121, dtic-GEMMA) pero con delta de dominio: campo -# 'provider'/'cuenta_origen' (D045 §2.3/§11) y, desde P201/Fase2, el VALOR REAL -# cifrado de cada key (D045 §10: NEXXA es la fuente de verdad, ya no candados, -# para API keys de terceros). 'identificador' es una ETIQUETA legible (ej. -# 'gemini-01'), no el secreto — el secreto vive solo en 'valor_cifrado', nunca -# en texto plano en disco ni en ningún log (ME-293/296). -# -# Dos ejes distintos, no confundir (corrección P201/Fase3, D045 §11): -# - cuenta_origen: PERMANENTE — qué cuenta ante el proveedor generó esta key. -# Informativo, nunca filtro de acceso (pool compartido, D045 §8). -# - ultimo_individuo / reservar / reportar / lib_usos.rb: EFÍMERO — qué individuo -# del ecosistema APIDs la tiene asignada ahora (o la tuvo la última vez). Una -# key se reclama y se libera — no tiene "dueño" en ese sentido. -# ============================================================================== -# NO hace: no llama a los providers externos, no valida las keys en sí — solo -# lleva el registro declarado (alta vía mini-app o cli_registrar.rb) -# ============================================================================== -# Salud real de keys (P204/Fase3, D045 §8) — el CONSUMIDOR es el árbitro del -# agotamiento, no NEXXA: solo él le pegó al proveedor real. reservar() aplica -# una reserva corta de contención al dispensar (evita doble-asignación -# concurrente, sin asumir agotamiento); reportar() recibe la señal real -# ('sana' renueva, 'liberada' suelta, 'agotada' recién ahí bloquea con -# disponible_desde). Ver registro.json: campos reservado_por/reservado_hasta. -# ============================================================================== - -require 'json' -require 'time' -require_relative 'lib_cripto' -require_relative 'lib_usos' -require_relative 'lib_estado' - -module Nexxa - module Registro - STATE_FILE = Estado.ruta('registro') - - # Reserva corta de contención (P204/Fase3, D045 §8) — no asume agotamiento, - # solo evita que 2 consumidores reciban la misma key mientras uno la está - # probando. Vence sola (evaluada en self.disponible, sin proceso de limpieza - # aparte) si nadie reporta nada; self.reportar la renueva o la libera. - RESERVA_TTL_SEGUNDOS = 600 - - # Estado vía Nexxa::Estado (P335/Fase 17): archivo o Postgres según NEXXA_ESTADO - def self.leer - Estado.leer('registro', STATE_FILE, { 'keys' => [] }) - end - - def self.guardar(state) - Estado.guardar('registro', STATE_FILE, state) - end - - # Leer-modificar-guardar atómico (nexxa-http y nexxa comparten el registro) - def self.mutar(&) - Estado.mutar('registro', STATE_FILE, { 'keys' => [] }, &) - end - - # provider: "gemini"/"groq"/... ; identificador: ETIQUETA legible (ej. "gemini-01"), - # nunca el secreto ; cuenta_origen: cuenta ante el proveedor que generó la key — - # PERMANENTE, informativo, no filtro de acceso (D045 §8/§11) ; reset_segundos: - # ciclo de cuota del proveedor, se persiste para que marcar_uso pueda recalcular - # disponible_desde sin que el caller tenga que volver a pasarlo ; valor: el - # secreto en texto plano — se cifra acá mismo, nunca se persiste sin cifrar - # (nil = alta solo de metadata, compatibilidad con registros viejos aún no - # migrados, D045 §9→§10). ultimo_uso: nil (default) = key nueva/sin agotar, - # disponible YA — nunca se asume 'se usó ahora' (bug real encontrado en - # P200/Fase4: registrar una key recién creada la dejaba "agotada" 24h por - # error, ME-603). Pasar ultimo_uso explícito solo cuando se sabe que la key - # SÍ se agotó en ese momento. - # por (P337/Fase 1): quién la dio de alta o la reemplazó, para el registro ('web:', 'cli'...) - def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil, por: nil) - ahora = Time.now - evento = nil - disponible_desde = ultimo_uso ? (Time.parse(ultimo_uso) + reset_segundos).iso8601(3) : ahora.iso8601(3) - ultimo_uso ||= ahora.iso8601(3) - - valor_cifrado = valor ? cifrar(valor) : nil - - mutar do |state| - existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - evento = existente ? 'editada' : 'alta' - if existente - existente.merge!( - 'ultimo_uso' => ultimo_uso, - 'disponible_desde' => disponible_desde, - 'cuenta_origen' => cuenta_origen, - 'reset_segundos' => reset_segundos - ) - existente['valor_cifrado'] = valor_cifrado if valor_cifrado - else - state['keys'] << { - 'provider' => provider, - 'identificador' => identificador, - 'cuenta_origen' => cuenta_origen, - 'reset_segundos' => reset_segundos, - 'ultimo_uso' => ultimo_uso, - 'ultimo_individuo' => nil, - 'disponible_desde' => disponible_desde, - 'valor_cifrado' => valor_cifrado, - 'activo' => true, - 'reservado_por' => nil, - 'reservado_hasta' => nil - } - end - state - end.tap do - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', en: ahora, - evento: evento, motivo: evento == 'editada' && valor ? 'valor reemplazado' : nil) - end - end - - # Edita metadata de una key existente (P201/Fase3) — NUNCA el valor (eso no - # se re-muestra, se reemplaza vía 'registrar' con un valor nuevo si hace - # falta rotarlo). Cada parámetro es opcional: solo se actualiza lo pasado. - def self.actualizar(provider:, identificador:, cuenta_origen: nil, reset_segundos: nil, activo: nil, por: nil) - entrada = nil - cambios = [] - mutar do |state| - entrada = buscar!(state, provider, identificador) - { 'cuenta_origen' => cuenta_origen, 'reset_segundos' => reset_segundos, 'activo' => activo }.each do |campo, valor| - next if valor.nil? || entrada[campo] == valor - - cambios << "#{campo}: #{entrada[campo].inspect} → #{valor.inspect}" - entrada[campo] = valor - end - state - end - # Qué cambió, sin ambigüedad (nunca el valor de la key: este método no lo toca) - unless cambios.empty? - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', - evento: 'editada', motivo: cambios.join('; ')) - end - entrada - end - - def self.buscar!(state, provider, identificador) - state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } || - raise("Key no encontrada: #{provider}/#{identificador}") - end - - IDENTIFICADOR_VALIDO = /\A[a-z0-9][a-z0-9._-]{0,63}\z/.freeze - - # Cambia el identificador de una key (P335/Fase 13). Único dentro del provider; rechazado mientras esté RESERVADA - # (el consumidor que la tiene reportaría con el nombre viejo). El historial previo de usos queda con el nombre - # anterior (log append-only) y se registra el evento 'renombrada'. Los pools los actualiza el llamador (Pools). - def self.renombrar(provider:, de:, a:, usuario: nil, ahora: Time.now) - a = a.to_s.strip - raise "Identificador inválido: '#{a}' (minúsculas, números, punto, guion o guion bajo)" unless a.match?(IDENTIFICADOR_VALIDO) - return leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == de } if a == de - - entrada = nil - mutar do |state| - entrada = buscar!(state, provider, de) - raise "Ya existe #{provider}/#{a}" if state['keys'].any? { |k| k['provider'] == provider && k['identificador'] == a } - if entrada['reservado_hasta'] && Time.parse(entrada['reservado_hasta']) > ahora - raise "#{provider}/#{de} está reservada por #{entrada['reservado_por']}: esperá a que la libere para renombrarla" - end - - entrada['identificador'] = a - state - end - Nexxa::Usos.registrar(provider: provider, identificador: a, individuo: usuario ? "web:#{usuario}" : 'web', - en: ahora, evento: 'renombrada', motivo: "antes #{de}") - entrada - end - - # Elimina una key del registro — destructivo, sin deshacer (P201/Fase3). - # No borra su historial en lib_usos.rb (log append-only, queda como evidencia). - def self.eliminar(provider:, identificador:, por: nil) - existia = nil - mutar do |state| - existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador } - state - end - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', evento: 'baja') if existia - !existia.nil? - end - - # Todas las keys con su estado de la taxonomía (P337/Fase 1), calculado sobre la key COMPLETA (sin valor_cifrado - # daría sin_valor) y recién después sin el valor (Regla 15). Lo que muestra nexxa-web: nada se recalcula allá. - def self.todas_con_estado(ahora = Time.now) - leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' }.merge(estado_de_key(k, ahora)) } - end - - # Todas las keys, solo metadata — para la vista de consulta de la mini-app - # (P201/Fase3). Nunca incluye valor_cifrado, bajo ningún caso (Regla 15). - def self.todas - leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' } } - end - - # Descifra y devuelve el valor real de una key — SOLO para el endpoint HTTP - # autenticado (Fase 2/2.4). El router de apids chat (router.rb) nunca llama - # a esto — sigue devolviendo solo metadata, texto plano sin el secreto. - def self.revelar(provider:, identificador:) - entrada = leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } - return nil unless entrada && entrada['valor_cifrado'] - - descifrar(entrada['valor_cifrado']) - end - - # Reserva corta de contención al dispensar (P204/Fase3, D045 §8) — reemplaza - # el bloqueo ciego de la vieja marcar_uso: NO asume agotamiento, solo evita - # que 2 consumidores reciban la misma key mientras uno la está probando. - # disponible_desde queda intacto — el agotamiento real solo lo aplica - # self.reportar(estado: 'agotada'), con la señal del consumidor. Se llama - # automático al dispensar (server.rb, GET /disponible). - def self.reservar(provider:, identificador:, individuo:) - ahora = Time.now - entrada = nil - mutar do |state| - entrada = aplicar_reserva(buscar!(state, provider, identificador), individuo, ahora) - state - end - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada', - hasta: entrada['reservado_hasta']) - entrada - end - - # Elegir la key libre y reservarla en UN paso atómico (P335/Fase 17). Antes se elegía (leer) y se reservaba después - # (otro leer/guardar): dos consumidores simultáneos podían recibir la misma key. Candidatas: las refs de un pool - # o todas las de un provider. Una key solo-metadata (sin valor_cifrado, D045 §9) se devuelve SIN reservar para que - # el llamador responda sin_valor_migrado como antes. => entrada (con valor_cifrado) o nil si no hay libre. - def self.reservar_libre(individuo:, refs: nil, provider: nil) - ahora = Time.now - elegida = nil - mutar do |state| - candidatas = state['keys'].select do |k| - refs ? Array(refs).include?("#{k['provider']}/#{k['identificador']}") : k['provider'] == provider - end - elegida = elegir_libre(candidatas) - aplicar_reserva(elegida, individuo, ahora) if elegida && elegida['valor_cifrado'] - state - end - if elegida && elegida['valor_cifrado'] - Nexxa::Usos.registrar(provider: elegida['provider'], identificador: elegida['identificador'], individuo: individuo, - en: ahora, evento: 'dispensada', hasta: elegida['reservado_hasta']) - end - elegida - end - - def self.aplicar_reserva(entrada, individuo, ahora) - entrada['ultimo_uso'] = ahora.iso8601(3) - entrada['ultimo_individuo'] = individuo - entrada['reservado_por'] = individuo - entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3) - entrada - end - - # Reporte real del consumidor sobre una key que tiene reservada (P204/Fase3, - # D045 §8) — el consumidor es el árbitro de salud, no NEXXA (solo él le pegó - # al proveedor real). Exige reservado_por == individuo — nadie reporta el - # estado de una key que no tiene reservada. - # 'sana' → renueva la reserva (sigue activo, evita que le venza en uso) - # 'liberada' → libera la reserva ya, sin tocar disponible_desde (buen - # ciudadano que terminó antes de tiempo) - # 'agotada' → recién acá se aplica el bloqueo real: disponible_desde = - # ahora + (liberar_en_segundos si el proveedor dio una pista - # real, si no el reset_segundos registrado como fallback) - # - # P334/Fase 4 (GEMMA, 2026-10-04): quien marcó una key 'agotada' puede DESHACER su propio reporte con - # 'liberada' aunque ya no la tenga reservada (agotada_por == individuo y el bloqueo sigue vigente). Caso real - # 2026-10-01 19:46: un 429 por minuto reportado como agotada bloqueó el pool compartido y el consumidor no podía - # revertirlo (409). Solo el autor del reporte: nadie libera lo que bloqueó otro. - def self.reportar(provider:, identificador:, individuo:, estado:, liberar_en_segundos: nil, motivo: nil) - ahora = Time.now - entrada = nil - evento = hasta = nil - mutar do |state| # sin 'return' adentro (P335/Fase 17): el bloque es una transacción - entrada = buscar!(state, provider, identificador) - if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora) - entrada['disponible_desde'] = ahora.iso8601(3) - entrada['agotada_por'] = nil - evento = 'revertida' - else - raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo - - evento, hasta = aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo) - end - state - end - # Registro completo (P337/Fase 1): cada reporte queda, con el motivo del proveedor y hasta cuándo - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: evento, - motivo: (motivo.to_s[0, 200] if %w[pausada agotada].include?(evento)), hasta: hasta) - entrada - end - - # => [evento de usos, hasta] — renovada (con el nuevo fin de reserva), liberada, pausada o agotada (con el fin del bloqueo) - def self.aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo) - case estado - when 'sana' - entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3) - ['renovada', entrada['reservado_hasta']] - when 'liberada' - entrada['reservado_por'] = nil - entrada['reservado_hasta'] = nil - ['liberada', nil] - when 'agotada' - reset_segundos = entrada['reset_segundos'] - unless reset_segundos - raise "Key #{entrada['provider']}/#{entrada['identificador']} sin reset_segundos persistido — no se puede reportar agotada" - end - - entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3) - entrada['bloqueo'] = tipo_bloqueo(liberar_en_segundos) - entrada['agotada_por'] = individuo - entrada['motivo_agotada'] = motivo.to_s.empty? ? nil : motivo.to_s[0, 200] - entrada['reservado_por'] = nil - entrada['reservado_hasta'] = nil - [entrada['bloqueo'] == 'pausa' ? 'pausada' : 'agotada', entrada['disponible_desde']] - else - raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)" - end - end - - # Liberación por un ADMIN desde nexxa-web (P335/Fase 7): la key queda disponible ya, sin reserva ni marca de - # agotada, sea quien sea que la bloqueó. El rastro queda en usos ('liberada-admin', con el usuario de la web). - def self.liberar_admin(provider:, identificador:, usuario:) - ahora = Time.now - entrada = nil - mutar do |state| - entrada = buscar!(state, provider, identificador) - entrada['disponible_desde'] = ahora.iso8601(3) if Time.parse(entrada['disponible_desde']) > ahora - entrada['reservado_por'] = nil - entrada['reservado_hasta'] = nil - entrada['agotada_por'] = nil - entrada['motivo_agotada'] = nil - entrada['bloqueo'] = nil - state - end - Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: "web:#{usuario}", en: ahora, - evento: 'liberada-admin') - entrada - end - - # ¿individuo puede deshacer el 'agotada' de esta key? Solo si lo reportó él y el bloqueo sigue vigente. - def self.revertible_por?(entrada, individuo, ahora = Time.now) - entrada['agotada_por'] == individuo && Time.parse(entrada['disponible_desde']) > ahora - end - - # Estado del pool de un provider, por key, SIN el valor (P334/Fase 4): para diagnosticar desde un consumidor sin - # entrar a la mini-app. estado: inactiva | agotada | reservada | disponible. - def self.estado_pool(provider, ahora = Time.now) - estado_de(leer['keys'].select { |k| k['provider'] == provider }, ahora) - end - - # Estado de las keys de un pool (P335/Fase 5): mezcla proveedores, por eso cada fila trae su provider. - def self.estado_en(refs, ahora = Time.now) - estado_de(de_refs(refs), ahora) - end - - # Taxonomía CERRADA de estados (P337/Fase 1): la única fuente; nexxa-web y GEMMA la muestran, nunca la recalculan. - # Excluyentes y en este orden de precedencia. Campos uniformes: hasta = cuándo cambia de estado, por = quién - # reservó o bloqueó, motivo = lo que contestó el proveedor. - ESTADOS = %w[disponible en_uso en_pausa agotada desactivada sin_valor].freeze - # Un bloqueo de hasta esto es una PAUSA por límite del proveedor (el 429 por minuto); más largo, cuota agotada - PAUSA_MAX_SEG = 300 - - def self.estado_de(keys, ahora = Time.now) - keys.map { |k| { 'provider' => k['provider'], 'identificador' => k['identificador'] }.merge(estado_de_key(k, ahora)) } - end - - def self.estado_de_key(k, ahora = Time.now) - bloqueada = Time.parse(k['disponible_desde']) > ahora - reservada = k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora - e = if k['activo'] == false then { 'estado' => 'desactivada' } - elsif !k.key?('valor_cifrado') || k['valor_cifrado'].nil? then { 'estado' => 'sin_valor' } - elsif bloqueada - { 'estado' => k['bloqueo'] == 'pausa' ? 'en_pausa' : 'agotada', 'hasta' => k['disponible_desde'], - 'por' => k['agotada_por'], 'motivo' => k['motivo_agotada'] } - elsif reservada then { 'estado' => 'en_uso', 'hasta' => k['reservado_hasta'], 'por' => k['reservado_por'] } - else { 'estado' => 'disponible' } - end - { 'hasta' => nil, 'por' => nil, 'motivo' => nil }.merge(e) - .merge('ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo']) - end - - # 'pausa' (bloqueo corto, límite del proveedor) o 'agotada' (cuota del ciclo), decidido por la duración real - def self.tipo_bloqueo(segundos) - segundos && segundos.to_i <= PAUSA_MAX_SEG ? 'pausa' : 'agotada' - end - - def self.cifrar(valor) - Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).encrypt(valor) - end - - def self.descifrar(valor_cifrado) - Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).decrypt(valor_cifrado) - end - - # Devuelve la key elegible MENOS USADA RECIENTEMENTE del provider (rotación - # del pool, P204/Fase4, propuesta del Operador) — nil si ninguna es elegible. - # Antes usaba el primer match del array: si la primera key nunca se agotaba, - # las demás no se usaban jamás y quedaban en riesgo de que el proveedor las - # diera de baja por inactividad. min_by sobre ultimo_uso rota el pool solo, - # sin estado adicional (nil = nunca usada, va primero). Elegible = 'activo' - # ausente/true (compat keys viejas), disponible_desde vencido, y - # reservado_hasta ausente/nil/vencido (compat keys pre-P204/Fase3 — la - # reserva vence sola acá, evaluada al consultar, sin limpieza aparte). - def self.disponible(provider) - elegir_libre(leer['keys'].select { |k| k['provider'] == provider }) - end - - # Igual que disponible, pero dentro de un POOL (P335/Fase 4): refs "provider/identificador" que pueden mezclar - # proveedores. La menos usada recientemente entre las libres, sin importar el proveedor. - def self.disponible_en(refs) - elegir_libre(de_refs(refs)) - end - - def self.proxima_en(refs) - proxima_de(de_refs(refs)) - end - - # Criterio ÚNICO de "cuándo se libera" (P335/Fase 17): la más tardía entre el fin del agotamiento y el fin de la - # reserva. Antes solo miraba disponible_desde y, con todas las keys reservadas, anunciaba una hora ya pasada - # (caso real 2026-10-05 02:39: "la próxima se libera 2026-10-04T11:25"). => copia de la entrada con - # 'disponible_desde' = esa hora, o nil - def self.proxima_de(keys) - k = keys.select { |x| x['activo'] != false }.min_by { |x| libre_desde(x) } - k && k.merge('disponible_desde' => libre_desde(k).iso8601(3)) - end - - def self.libre_desde(k) - [Time.parse(k['disponible_desde']), k['reservado_hasta'] && Time.parse(k['reservado_hasta'])].compact.max - end - - def self.de_refs(refs) - refs = Array(refs) - leer['keys'].select { |k| refs.include?("#{k['provider']}/#{k['identificador']}") } - end - - # Criterio ÚNICO de "libre ahora" (activa, no agotada, sin reserva vigente) y de cuál dar (la menos usada). - def self.elegir_libre(keys) - ahora = Time.now - keys - .select do |k| - k['activo'] != false && - Time.parse(k['disponible_desde']) <= ahora && - (k['reservado_hasta'].nil? || Time.parse(k['reservado_hasta']) <= ahora) - end - .min_by { |k| k['ultimo_uso'] ? Time.parse(k['ultimo_uso']) : Time.at(0) } - end - - # Próxima key de un provider a liberarse (para responder explícito, nunca - # silencioso) — también excluye desactivadas, nunca las ofrece como "próxima". - def self.proxima(provider) - proxima_de(leer['keys'].select { |k| k['provider'] == provider }) - end - end -end diff --git a/servicios/nexxa/organismo/lib_tokens.rb b/servicios/nexxa/organismo/lib_tokens.rb deleted file mode 100644 index 9b4713c6..00000000 --- a/servicios/nexxa/organismo/lib_tokens.rb +++ /dev/null @@ -1,120 +0,0 @@ -# frozen_string_literal: true - -# lib_tokens.rb — Autenticación por-individuo (D045 §10, P201/Fase2) -# ============================================================================== -# Cada individuo F1 tiene su propio token — generado y guardado en el storage -# de NEXXA, sin dependencia de candados. Se guarda el HASH del token (SHA256), -# nunca el token en sí — mismo principio que un password: no hace falta el -# valor real para VERIFICAR posesión, solo para la emisión inicial (que se -# muestra una única vez al generarlo, nunca se vuelve a mostrar después). -# ============================================================================== - -require 'json' -require 'securerandom' -require 'digest' -require 'time' -require 'openssl' -require_relative 'lib_estado' - -module Nexxa - module Tokens - STATE_FILE = Estado.ruta('tokens') - - # Estado vía Nexxa::Estado (P335/Fase 17) - def self.leer - Estado.leer('tokens', STATE_FILE, { 'tokens' => [] }) - end - - def self.guardar(state) - Estado.guardar('tokens', STATE_FILE, state) - end - - def self.mutar(&) - Estado.mutar('tokens', STATE_FILE, { 'tokens' => [] }, &) - end - - # Genera un token nuevo para un individuo — devuelve el token EN CLARO, - # una única vez (el caller es responsable de entregárselo al individuo y - # nunca volver a mostrarlo). Si el individuo ya tenía token, lo reemplaza - # (rotación simple). - def self.generar(individuo) - token = SecureRandom.hex(32) - mutar do |state| - state['tokens'].reject! { |t| t['individuo'] == individuo } - state['tokens'] << { - 'individuo' => individuo, - 'token_hash' => Digest::SHA256.hexdigest(token), - 'creado' => Time.now.iso8601 - } - state - end - token - end - - # Verifica un token recibido (ej. header Authorization) — devuelve el - # nombre del individuo si es válido, nil si no. Comparación de tiempo - # constante (security-review, P201/Fase2/2.6): comparar hashes con == a - # secas es vulnerable en teoría a timing attacks — OpenSSL.fixed_length_secure_compare - # evita que el tiempo de respuesta filtre en qué byte difiere. - def self.verificar(token) - return nil if token.to_s.strip.empty? - - hash = Digest::SHA256.hexdigest(token) - entrada = leer['tokens'].find do |t| - t['token_hash'].bytesize == hash.bytesize && - OpenSSL.fixed_length_secure_compare(t['token_hash'], hash) - end - entrada && entrada['individuo'] - end - - # Todos los individuos con token registrado — solo metadata (individuo + - # fecha de creación), NUNCA el hash ni el token (P201/Fase3, mismo criterio - # que Registro.todas con valor_cifrado). - def self.listar - leer['tokens'].map { |t| { 'individuo' => t['individuo'], 'creado' => t['creado'] } } - end - - # Revoca el acceso de un individuo — borra su entrada, sin deshacer. El - # individuo necesita un token nuevo (generar) para volver a consultar NEXXA. - def self.revocar(individuo) - existia = nil - mutar do |state| - existia = state['tokens'].reject! { |t| t['individuo'] == individuo } - state - end - !existia.nil? - end - - # Cifrado de punta a punta (P204, "Aplica Pilares" — reemplaza la - # decisión previa de diferirlo): cada individuo registra SU PROPIA clave - # pública RSA — la privada nunca sale del individuo, nunca la ve NEXXA ni - # GEMMA. Self-service: solo el individuo autenticado con SU token puede - # tocar SU propia clave (server.rb lo gatea) — ni siquiera un admin la - # puede setear por otro, porque eso rompería la propiedad de punta a - # punta (si un tercero pudiera registrar la clave pública "en nombre de" - # otro, podría sustituirla por una propia y interceptar). - def self.registrar_clave_publica(individuo:, clave_publica_pem:) - # Validar que es una clave pública RSA válida antes de guardar — falla - # rápido con un error claro en vez de guardar basura silenciosamente. - OpenSSL::PKey::RSA.new(clave_publica_pem) - - mutar do |state| - entrada = state['tokens'].find { |t| t['individuo'] == individuo } - raise "Individuo sin token: #{individuo}" unless entrada - - entrada['clave_publica_pem'] = clave_publica_pem - state - end - true - rescue OpenSSL::PKey::RSAError - raise 'Clave pública inválida — se espera PEM RSA (ej. openssl rsa -pubout)' - end - - # nil si el individuo no registró clave — server.rb cae a texto plano en - # ese caso (compatibilidad, no rompe consumidores que todavía no migraron). - def self.clave_publica(individuo) - entrada = leer['tokens'].find { |t| t['individuo'] == individuo } - entrada && entrada['clave_publica_pem'] - end - end -end diff --git a/servicios/nexxa/organismo/lib_usos.rb b/servicios/nexxa/organismo/lib_usos.rb deleted file mode 100644 index 80cd0a8e..00000000 --- a/servicios/nexxa/organismo/lib_usos.rb +++ /dev/null @@ -1,79 +0,0 @@ -# frozen_string_literal: true - -# lib_usos.rb — Registro de uso por individuo (P201/Fase3, D045 §11, ME-605 punto 5) -# ============================================================================== -# Trazabilidad de quién recibió qué key y cuándo — separado del dato de origen -# (cuenta_origen, en lib_registro.rb) y separado de registro.json (estado actual) -# para no mezclar "foto del ahora" con "historial acumulado". Append-only, -# JSONL — mismo espíritu que un log de bitácora: se escribe, no se reescribe. -# ============================================================================== - -require 'json' -require 'time' -require_relative 'lib_estado' - -module Nexxa - module Usos - LOG_FILE = Estado::USOS_LOG # fuente única de la ruta (P335/Fase 17) - - # Registro COMPLETO de lo que pasa con cada key (P337/Fase 1). Códigos estables (hay filas guardadas con ellos); - # nexxa-web los traduce a palabras: - EVENTOS = %w[dispensada liberada renovada pausada agotada revertida liberada-admin alta editada renombrada baja].freeze - # Qué significa cada evento en palabras: fuente ÚNICA para nexxa-web y GEMMA (viaja en /usos y /resumen) - TEXTOS = { - 'dispensada' => 'entregada', 'liberada' => 'devuelta', 'renovada' => 'reserva renovada', - 'pausada' => 'en pausa por límite del proveedor', 'agotada' => 'agotada (cuota)', 'revertida' => 'reporte deshecho', - 'liberada-admin' => 'liberada por admin', 'alta' => 'dada de alta', 'editada' => 'editada', - 'renombrada' => 'renombrada', 'baja' => 'dada de baja', - 'agotada-previa' => 'bloqueada (registro anterior a 2.0.0: no distingue pausa de cuota)' - }.freeze - - # Un 'agotada' sin 'hasta' es de antes de 2.0.0, cuando un 429 de un minuto también se guardaba como agotada: - # contarlo como cuota inflaría los agotamientos (caso real 2026-10-05: 32 en 24 h, casi todos pausas). - def self.clase(u) - u['evento'] == 'agotada' && u['hasta'].nil? ? 'agotada-previa' : u['evento'] - end - - # motivo: lo que contestó el proveedor (pausada/agotada), qué cambió (editada) o el nombre anterior (renombrada). - # hasta: hasta cuándo queda así (fin de la reserva o del bloqueo). Nunca valores de keys. - def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada', motivo: nil, hasta: nil) - linea = { - 'provider' => provider, - 'identificador' => identificador, - 'individuo' => individuo, - 'evento' => evento, - 'en' => en.iso8601, - 'motivo' => motivo, - 'hasta' => hasta - } - Estado.usos_registrar(linea) - end - - # Más reciente primero. Filtros opcionales; horas: solo la ventana de las últimas N horas - def self.historial(provider: nil, identificador: nil, individuo: nil, evento: nil, horas: nil, limit: 100) - Estado.usos_historial(provider: provider, identificador: identificador, individuo: individuo, evento: evento, - desde: horas && (Time.now - (horas.to_f * 3600)), limit: limit) - .map { |u| u.merge('clase' => clase(u), 'texto' => TEXTOS.fetch(clase(u), u['evento'])) } - end - - # Lo que muestra el Dashboard (P337/Fase 1): cuántas keys en cada estado AHORA (todos los estados, también los - # que están en 0: un número ausente se presta a interpretar) y qué pasó en las últimas N horas, en total y por key. - # keys: Registro.todas_con_estado. eventos: inyectable (tests); por defecto, el registro de la ventana. - def self.resumen(keys, horas: 24, eventos: nil) - eventos ||= historial(horas: horas, limit: 1_000_000) - contar = ->(lista) { (EVENTOS + ['agotada-previa']).to_h { |e| [e, lista.count { |u| clase(u) == e }] } } - por_key = keys.map do |k| - propios = eventos.select { |u| u['provider'] == k['provider'] && u['identificador'] == k['identificador'] } - k.slice('provider', 'identificador', 'estado', 'hasta', 'por', 'motivo', 'ultimo_uso', 'ultimo_individuo') - .merge('eventos' => contar.call(propios), 'ultimo_evento' => propios.first) - end - { - 'horas' => horas, - 'textos' => TEXTOS, - 'ahora' => Nexxa::Registro::ESTADOS.to_h { |e| [e, keys.count { |k| k['estado'] == e }] }, - 'eventos' => contar.call(eventos), - 'por_key' => por_key.sort_by { |k| [k['provider'].to_s, k['identificador'].to_s] } - } - end - end -end diff --git a/servicios/nexxa/organismo/nexxa.rb b/servicios/nexxa/organismo/nexxa.rb deleted file mode 100644 index 01250eb6..00000000 --- a/servicios/nexxa/organismo/nexxa.rb +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# nexxa.rb — Entry point del router (uso CLI y, a futuro, canal apids chat) -# Uso: ruby nexxa.rb "disponible gemini" - -require_relative 'router' - -estimulo = ARGV.join(' ') -if estimulo.empty? - puts "Uso: ruby nexxa.rb \"disponible \"" - exit 1 -end - -puts Nexxa::Router.procesar(estimulo) diff --git a/servicios/nexxa/organismo/router.rb b/servicios/nexxa/organismo/router.rb deleted file mode 100644 index bc30d5c2..00000000 --- a/servicios/nexxa/organismo/router.rb +++ /dev/null @@ -1,44 +0,0 @@ -# frozen_string_literal: true - -# router.rb — Matching exacto estímulo → estado, cero semántica en runtime -# ============================================================================== -# NEXXA-F1 (P200) — sin LLM en ningún punto (D045 §1/§4). Responde consultas de -# pares vía apids chat con formato fijo, nunca silencioso ante agotamiento. -# ============================================================================== - -require_relative 'lib_registro' - -module Nexxa - module Router - # estimulo esperado: "disponible " (ej. "disponible gemini") - def self.procesar(estimulo) - partes = estimulo.to_s.strip.split(/\s+/) - return "ERROR: estímulo no reconocido — formato esperado: 'disponible '" unless partes[0] == 'disponible' && partes[1] - - provider = partes[1] - key = Nexxa::Registro.disponible(provider) - - if key - "#{provider.upcase}: viva (#{key['identificador']}, cuenta: #{key['cuenta_origen']})" - else - proxima = Nexxa::Registro.proxima(provider) - if proxima - restante = Time.parse(proxima['disponible_desde']) - Time.now - "#{provider.upcase}: agotado, próxima en #{formatear_tiempo(restante)}" - else - "#{provider.upcase}: sin keys registradas" - end - end - end - - def self.formatear_tiempo(segundos) - segundos = [segundos, 0].max - horas = (segundos / 3600).to_i - mins = ((segundos % 3600) / 60).to_i - partes = [] - partes << "#{horas}h" if horas > 0 - partes << "#{mins}m" if mins > 0 - partes.empty? ? '< 1m' : partes.join(' ') - end - end -end diff --git a/servicios/nexxa/organismo/server.rb b/servicios/nexxa/organismo/server.rb deleted file mode 100644 index bbd74d77..00000000 --- a/servicios/nexxa/organismo/server.rb +++ /dev/null @@ -1,988 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# server.rb — Servicio HTTP/API de NEXXA (P201/Fase2-4) -# ============================================================================== -# A diferencia de gemma/tools/docs_web/server.rb y gemma/tools/sala/hub.rb -# (que corren en el MISMO host que nginx, loopback alcanza), NEXXA vive en su -# propio LXC (10.0.10.163) — srvv-proxy (10.0.10.117) le hace proxy_pass -# cross-host, así que necesita escuchar en la interfaz real, no en loopback -# (corregido P201/Fase4 tras el primer 502 real contra nexxa.frlr.utn.edu.ar). -# Sigue sin exposición directa a internet: la LAN 10.0.10.0/24 no es -# ruteable desde afuera, nginx sigue siendo el único gateway público. -# -# Dos superficies de auth, ambas resueltas por NEXXA mismo — sin nginx -# Basic Auth ni credenciales de GEMMA (corrección del Operador, P201/Fase4): -# - GET /disponible/ → individuo F1, token Bearer (lib_tokens.rb); mente|red = SU pool (P335) -# - GET /, GET /keys, GET /consumidores, GET /pools → cualquier usuario logueado (solo lectura) -# - PATCH/DELETE /keys, POST /keys/

//liberar, POST/DELETE /consumidores, POST/DELETE /pools, -# POST /alta, todo /usuarios → solo perfil 'admin' — 'operador' es -# read-only (corrección 2026-08-03: el diseño original dejaba mutar keys/ -# consumidores a cualquier logueado, error — solo /usuarios estaba bien) -# ============================================================================== - -require 'webrick' -require 'json' -require_relative 'lib_registro' -require_relative 'lib_pools' -require_relative 'lib_tokens' -require_relative 'lib_checkins' -require_relative 'lib_auth' -require_relative 'lib_envelope' - -PORT = 4568 -WEB_DIR = File.expand_path('../web', __dir__).freeze -SESSION_COOKIE = 'nexxa_session' - -# Versión semántica real (P204/Fase4, pedido del Operador: "tipo v1.0.1", el -# build stamp por timestamp no se entendía como versión) — vive en el archivo -# VERSION junto a este script, se bumpea a mano en cada deploy con cambios -# reales (mismo criterio que cualquier changelog: subir la versión es una -# decisión de quien publica). Sirve para confirmar en la mini-app que un -# deploy realmente llegó. -# -# Se lee del disco EN CADA REQUEST (self.version, no una constante cacheada -# al arrancar) — a propósito, corrección real (Operador, "hiciste cambios sin -# versionar la app"): un deploy de solo estáticos (HTML/CSS/JS) no reinicia -# el proceso, así que una constante cacheada nunca hubiera reflejado ese -# bump sin reiniciar igual — justo el caso más común. Costo despreciable -# (un archivo de una línea) frente a que el número mienta. -VERSION_FILE = File.expand_path('VERSION', __dir__).freeze -COMMIT_FILE = File.expand_path('COMMIT', __dir__).freeze -def version_actual - File.read(VERSION_FILE).strip -end - -# Cifrado de punta a punta (P204) — arma el fragmento de respuesta con el -# valor real, cifrado para EL INDIVIDUO SI tiene clave pública registrada, en -# texto plano si no (compatibilidad — un consumidor que todavía no migró a -# su propia clave sigue funcionando, protegido solo por TLS como antes). -# Un solo lugar decide esto — reusado por la dispensa normal y por -# "siguiente" en /reportar, para no repetir el criterio. -def empaquetar_valor(individuo, valor) - clave_publica = Nexxa::Tokens.clave_publica(individuo) - if clave_publica - { valor_cifrado: Nexxa::Envelope.cifrar_para(clave_publica, valor), cifrado: true } - else - { valor: valor, cifrado: false } - end -end - -# Todo reinicio del servicio invalida las sesiones activas (P204/Fase4, pedido -# del Operador) — hace el reinicio visible: quien estaba conectado tiene que -# volver a loguearse, en vez de seguir viendo el panel sin saber si el deploy -# surtió efecto. Sesiones son de por sí efímeras (SESSION_TTL=8h, lib_auth.rb) — -# perderlas en un restart no es una pérdida real, es la señal que se pidió. -Nexxa::Auth.guardar_sesiones({}) - -server = WEBrick::HTTPServer.new( - Port: PORT, - BindAddress: '0.0.0.0', - Logger: WEBrick::Log.new($stdout, WEBrick::Log::INFO), - AccessLog: [[$stdout, WEBrick::AccessLog::COMMON_LOG_FORMAT]] -) - -def individuo_autenticado(req) - auth = req['Authorization'].to_s - return nil unless auth.start_with?('Bearer ') - - Nexxa::Tokens.verificar(auth.sub('Bearer ', '').strip) -end - -# Sesión del Operador (P201/Fase4) — cookie de sesión propia de NEXXA, no -# Basic Auth de nginx. req.cookies ya viene parseado por WEBrick (stdlib). -def token_de_sesion(req) - cookie = req.cookies.find { |c| c.name == SESSION_COOKIE } - cookie&.value -end - -def sesion_actual(req) - Nexxa::Auth.sesion(token_de_sesion(req)) -end - -def operador_autenticado?(req) - !sesion_actual(req).nil? -end - -# Quién hizo algo desde la web, para el registro de usos (P337/Fase 1) -def quien(req) - u = sesion_actual(req)&.dig('usuario') - u ? "web:#{u}" : 'api' -end - -def admin_autenticado?(req) - sesion_actual(req)&.dig('perfil') == 'admin' -end - -# WEBrick::Cookie (gem webrick 1.8.1) no expone HttpOnly/SameSite — se arma -# el header Set-Cookie a mano para tener las 3 flags recomendadas (OWASP): -# HttpOnly (JS no puede leerla), Secure (solo por HTTPS — nginx termina TLS -# por delante), SameSite=Strict (mitiga CSRF). Leer sigue vía req.cookies -# (eso sí soportado), esto solo afecta cómo se escribe. -def set_cookie_sesion(res, token) - res['Set-Cookie'] = "#{SESSION_COOKIE}=#{token}; Path=/; Max-Age=#{Nexxa::Auth::SESSION_TTL}; HttpOnly; Secure; SameSite=Strict" -end - -def borrar_cookie_sesion(res) - res['Set-Cookie'] = "#{SESSION_COOKIE}=; Path=/; Max-Age=0; HttpOnly; Secure; SameSite=Strict" -end - -def rechazar_no_autenticado(res) - res.status = 401 - res.content_type = 'application/json' - res.body = { error: 'No autenticado' }.to_json -end - -def rechazar_no_admin(res) - res.status = 403 - res.content_type = 'application/json' - res.body = { error: 'Requiere perfil admin' }.to_json -end - -NEXXA_APP_FILE = File.expand_path('index.html', WEB_DIR).freeze -LOGIN_FILE = File.expand_path('login.html', WEB_DIR).freeze - -# GET / — sirve login.html o index.html según la sesión (P201/Fase4). Se lee -# del disco en cada request (mismo criterio que docs_web/server.rb, P164). -# -# Cache busting (P335, 2026-10-04): los .js/.css los sirve un FileHandler estático y el navegador se quedaba con el -# app.js viejo tras un deploy (el Operador veía el menú Pools nuevo pero la sección vacía). Al servir el HTML se le -# agrega ?v= a cada /js/ y /css/: cada versión nueva obliga a bajar los archivos nuevos. El HTML en sí no se -# cachea (no-cache), así siempre trae la versión vigente. -def html_con_version(ruta) - # encoding explícito: systemd corre con locale C (US-ASCII) y el gsub sobre un HTML con acentos daba 500 (1.4.1) - File.read(ruta, encoding: 'UTF-8').gsub(%r{(["'])(/(?:js|css)/[^"'?]+\.(?:js|css))\1}) { "#{$1}#{$2}?v=#{version_actual}#{$1}" } -end - -server.mount_proc '/' do |req, res| - res.status = 200 - res.content_type = 'text/html; charset=utf-8' - res['Cache-Control'] = 'no-cache' - res.body = html_con_version(operador_autenticado?(req) ? NEXXA_APP_FILE : LOGIN_FILE) -end - -# Estáticos (css/js) — públicos a propósito: login.html los necesita antes de -# autenticar. WEBrick::HTTPServlet::FileHandler es la clase estándar de la -# stdlib para esto (no reinventar servido de estáticos). -server.mount('/css', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'css')) -server.mount('/js', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'js')) - -# POST /login — body {usuario, password}. Si matchea, crea sesión y devuelve la cookie. -server.mount_proc '/login' do |req, res| - res.content_type = 'application/json' - if req.request_method != 'POST' - res.status = 405 - res.body = { error: 'Método no permitido — usar POST' }.to_json - next - end - - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.body = { error: 'JSON inválido' }.to_json - next - end - - entrada = Nexxa::Auth.autenticar(usuario: body['usuario'], password: body['password']) - if entrada - token = Nexxa::Auth.crear_sesion(entrada['usuario'], entrada['perfil']) - set_cookie_sesion(res, token) - res.status = 200 - res.body = { ok: true, usuario: entrada['usuario'], perfil: entrada['perfil'] }.to_json - else - res.status = 401 - res.body = { error: 'Usuario o password incorrectos' }.to_json - end -end - -# POST /logout — cierra la sesión actual, si había una. -server.mount_proc '/logout' do |req, res| - res.content_type = 'application/json' - Nexxa::Auth.cerrar_sesion(token_de_sesion(req)) - borrar_cookie_sesion(res) - res.status = 200 - res.body = { ok: true }.to_json -end - -# GET /session — quién está logueado ahora (para que el frontend sepa qué -# mostrar, ej. la sección Usuarios solo si perfil admin). -# GET /version — build stamp público (P204/Fase4) — sin auth a propósito, -# mismo criterio que css/js: login.html también necesita mostrarlo, antes de -# autenticar. -server.mount_proc '/version' do |req, res| - res.status = 200 - res.content_type = 'application/json' - # commit: el que dejó `gemma nexxa desplegar` (organismo/COMMIT, generado al desplegar, nunca en el repo — P335/F15) - commit = File.exist?(COMMIT_FILE) ? File.read(COMMIT_FILE).strip : nil - res.body = { version: version_actual, commit: commit }.to_json -end - -server.mount_proc '/session' do |req, res| - res.content_type = 'application/json' - sesion = sesion_actual(req) - if sesion - res.status = 200 - res.body = sesion.to_json - else - rechazar_no_autenticado(res) - end -end - -# GET /keys — metadata de todas las keys, NUNCA el valor -# PATCH /keys// — editar cuenta_origen/reset_segundos/activo -# DELETE /keys// — eliminar del registro (destructivo) -# (P201/Fase3-4, D045 §8/§11). Requiere sesión de Operador (lib_auth.rb). -# -# Clase de servlet, no mount_proc: WEBrick::HTTPServlet::ProcHandler (lo que -# usa mount_proc) solo define do_GET/do_POST/do_PUT (ver prochandler.rb) — -# nunca do_DELETE ni do_PATCH, así que un mount_proc con 'case request_method' -# nunca llega a ejecutarse para esos verbos (WEBrick responde 405 antes). -class KeysServlet < WEBrick::HTTPServlet::AbstractServlet - def partes_de(req) - req.path.sub(%r{\A/keys/?}, '').split('/') - end - - def do_GET(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - - res.content_type = 'application/json' - res.status = 200 - # Cada key trae en qué pools está (P335/Fase 12): la sección APIs lo muestra y avisa al eliminar - pools = Nexxa::Pools.leer - # Y su estado de la taxonomía calculado acá (P337/Fase 1): la web lo muestra, no lo recalcula - res.body = Nexxa::Registro.todas_con_estado.map { |k| k.merge('pools' => Nexxa::Pools.de_key(k['provider'], k['identificador'], pools)) }.to_json - end - - # POST /keys///liberar — admin libera una key agotada o reservada (P335/Fase 7) - def do_POST(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - partes = partes_de(req) - unless partes.size == 3 && partes[2] == 'liberar' - res.status = 400 - res.body = { error: 'Uso: POST /keys///liberar' }.to_json - return - end - - Nexxa::Registro.liberar_admin(provider: partes[0], identificador: partes[1], usuario: sesion_actual(req)['usuario']) - res.status = 200 - res.body = { ok: true, provider: partes[0], identificador: partes[1] }.to_json - rescue RuntimeError => e - res.status = 404 - res.body = { error: e.message }.to_json - end - - def do_PATCH(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - partes = partes_de(req) - if partes.size != 2 - res.status = 400 - res.body = { error: 'Uso: PATCH /keys//' }.to_json - return - end - - provider, identificador = partes - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.body = { error: 'JSON inválido' }.to_json - return - end - - begin - # Renombrar primero (P335/Fase 13): registro + pools; el resto de los campos se aplica sobre el nombre nuevo - nuevo = body['identificador'].to_s.strip - if !nuevo.empty? && nuevo != identificador - Nexxa::Registro.renombrar(provider: provider, de: identificador, a: nuevo, usuario: sesion_actual(req)&.dig('usuario')) - Nexxa::Pools.renombrar_key(provider: provider, de: identificador, a: nuevo) - identificador = nuevo - end - entrada = Nexxa::Registro.actualizar( - provider: provider, - identificador: identificador, - cuenta_origen: body['cuenta_origen'], - reset_segundos: body['reset_segundos']&.to_i, - activo: body.key?('activo') ? body['activo'] : nil, por: quien(req) - ) - res.status = 200 - res.body = entrada.reject { |k, _| k == 'valor_cifrado' }.to_json - rescue RuntimeError => e - res.status = e.message.start_with?('Key no encontrada') ? 404 : 409 - res.body = { error: e.message }.to_json - end - end - - def do_DELETE(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - partes = partes_de(req) - if partes.size != 2 - res.status = 400 - res.body = { error: 'Uso: DELETE /keys//' }.to_json - return - end - - provider, identificador = partes - borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador, por: quien(req)) - Nexxa::Pools.olvidar_key(provider: provider, identificador: identificador) if borrado # sin refs colgadas (P335) - if borrado - res.status = 200 - res.body = { ok: true }.to_json - else - res.status = 404 - res.body = { error: 'Key no encontrada' }.to_json - end - end -end - -server.mount '/keys', KeysServlet - -# /pools — pools por individuo (P335/Fase 5): GET para cualquier operador (estado de cada key, nunca valores); -# asignar/quitar solo admin (ME-682/ME-683, gate explícito en cada escritura). -# GET /pools -# POST /pools// body {provider, identificador} -# PUT /pools// body {refs: ["prov/id", ...]} (reemplaza; [] = vaciar) -# POST /pools/////mover (al otro rol) -# DELETE /pools//// -class PoolsServlet < WEBrick::HTTPServlet::AbstractServlet - def partes_de(req) - req.path.sub(%r{\A/pools/?}, '').split('/') - end - - def responder(res, status, cuerpo) - res.status = status - res.content_type = 'application/json' - res.body = cuerpo.to_json - end - - def do_GET(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - - responder(res, 200, { roles: Nexxa::Pools::ROLES, individuos: Nexxa::Pools.con_estado }) - end - - def do_POST(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - partes = partes_de(req) - if partes.size == 5 && partes[4] == 'mover' - a = Nexxa::Pools.mover(individuo: partes[0], de: partes[1], provider: partes[2], identificador: partes[3]) - return responder(res, 200, { individuo: partes[0], de: partes[1], a: a }) - end - return responder(res, 400, { error: 'Uso: POST /pools// {provider, identificador} | POST /pools/////mover' }) if partes.size != 2 - - body = begin - JSON.parse(req.body.to_s) - rescue JSON::ParserError - return responder(res, 400, { error: 'JSON inválido' }) - end - pool = Nexxa::Pools.asignar(individuo: partes[0], rol: partes[1], - provider: body['provider'].to_s, identificador: body['identificador'].to_s) - responder(res, 200, { individuo: partes[0], rol: partes[1], pool: pool }) - rescue RuntimeError => e - responder(res, 400, { error: e.message }) - end - - # Editar el pool entero desde nexxa-web (P335/Fase 12): valida todas las refs antes de escribir - def do_PUT(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - partes = partes_de(req) - return responder(res, 400, { error: 'Uso: PUT /pools// {refs: ["provider/identificador", ...]}' }) if partes.size != 2 - - body = begin - JSON.parse(req.body.to_s) - rescue JSON::ParserError - return responder(res, 400, { error: 'JSON inválido' }) - end - return responder(res, 400, { error: "Falta 'refs' (lista; vacía = vaciar el pool)" }) unless body['refs'].is_a?(Array) - - pool = Nexxa::Pools.reemplazar(individuo: partes[0], rol: partes[1], refs: body['refs']) - responder(res, 200, { individuo: partes[0], rol: partes[1], pool: pool }) - rescue RuntimeError => e - responder(res, 400, { error: e.message }) - end - - def do_DELETE(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - partes = partes_de(req) - return responder(res, 400, { error: 'Uso: DELETE /pools////' }) if partes.size != 4 - - quitada = Nexxa::Pools.quitar(individuo: partes[0], rol: partes[1], provider: partes[2], identificador: partes[3]) - quitada ? responder(res, 200, { ok: true }) : responder(res, 404, { error: 'La key no está en ese pool' }) - rescue RuntimeError => e - responder(res, 400, { error: e.message }) - end -end -server.mount '/pools', PoolsServlet - -# GET /usos — historial de eventos (dispensada/agotada) para la mini-app (P204/Fase4). -# Read-only, mismo criterio de auth que GET /keys (cualquier operador logueado). -# Usos.historial ya existía (P201/Fase3) — nunca se había montado por HTTP. -# P337/Fase 1: registro completo con filtros — ?provider=&identificador=&individuo=&evento=&horas=&limit= (máx 2000) -server.mount_proc '/usos' do |req, res| - next rechazar_no_autenticado(res) unless operador_autenticado?(req) - - q = req.query - filtros = %w[provider identificador individuo evento].to_h { |k| [k.to_sym, q[k].to_s.empty? ? nil : q[k].to_s] } - limit = (q['limit'] || 100).to_i.clamp(1, 2000) - horas = q['horas'].to_s.empty? ? nil : q['horas'].to_f - res.status = 200 - res.content_type = 'application/json' - res.body = Nexxa::Usos.historial(**filtros, horas: horas, limit: limit).to_json -end - -# GET /resumen?horas=24 — P337/Fase 1: cuántas keys en cada estado AHORA y qué pasó en la ventana (por evento y por -# key). Lo que el Dashboard muestra, calculado acá. -server.mount_proc '/resumen' do |req, res| - next rechazar_no_autenticado(res) unless operador_autenticado?(req) - - horas = (req.query['horas'] || 24).to_f.clamp(1, 24 * 31) - res.status = 200 - res.content_type = 'application/json' - res.body = Nexxa::Usos.resumen(Nexxa::Registro.todas_con_estado, horas: horas).to_json -end - -# GET /consumidores — individuos con token registrado (metadata) -# POST /consumidores — genera/rota token para un individuo, body -# {individuo} — el token en claro se entrega -# UNA VEZ en la respuesta (mismo criterio que -# el alta de una key: se muestra al crear, -# nunca más — el Operador lo guarda en -# candados o se lo entrega al individuo) -# DELETE /consumidores/ — revoca el acceso (destructivo) -# (P201/Fase3-4). Requiere sesión de Operador (lib_auth.rb). -class ConsumidoresServlet < WEBrick::HTTPServlet::AbstractServlet - def individuo_de(req) - req.path.sub(%r{\A/consumidores/?}, '') - end - - def do_GET(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - - res.content_type = 'application/json' - res.status = 200 - # Cada individuo trae el resumen de sus pools (P335/Fase 12): Individuos y Dashboard lo muestran - res.body = Nexxa::Tokens.listar.map { |c| c.merge('pools' => Nexxa::Pools.resumen(c['individuo'])) }.to_json - end - - def do_POST(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.body = { error: 'JSON inválido' }.to_json - return - end - - individuo = body['individuo'].to_s.strip - if individuo.empty? - res.status = 400 - res.body = { error: 'Falta "individuo"' }.to_json - return - end - - token = Nexxa::Tokens.generar(individuo) - res.status = 201 - res.body = { individuo: individuo, token: token }.to_json - end - - def do_DELETE(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - individuo = individuo_de(req) - if individuo.empty? - res.status = 400 - res.body = { error: 'Uso: DELETE /consumidores/' }.to_json - return - end - - revocado = Nexxa::Tokens.revocar(individuo) - Nexxa::Pools.olvidar_individuo(individuo) if revocado # sin token no pide: sus pools no quedan colgados - if revocado - res.status = 200 - res.body = { ok: true }.to_json - else - res.status = 404 - res.body = { error: 'Individuo no encontrado' }.to_json - end - end -end - -server.mount '/consumidores', ConsumidoresServlet - -# GET /usuarios — metadata de todos los usuarios del panel -# POST /usuarios — alta, body {usuario, password, perfil} -# PATCH /usuarios/ — editar perfil/activo/password, body {perfil, activo, password} -# DELETE /usuarios/ — eliminar (destructivo) -# (P201/Fase4, corrección del Operador) — gateado a perfil 'admin', no alcanza -# con estar logueado. Guardia de negocio: nunca desactivar/degradar/borrar al -# último admin activo — dejaría el panel sin nadie que pueda gestionar usuarios. -class UsuariosServlet < WEBrick::HTTPServlet::AbstractServlet - def usuario_de(req) - req.path.sub(%r{\A/usuarios/?}, '') - end - - def do_GET(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - res.status = 200 - res.body = Nexxa::Auth.listar.to_json - end - - def do_POST(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.body = { error: 'JSON inválido' }.to_json - return - end - - faltantes = %w[usuario password perfil].reject { |k| body[k].to_s.strip != '' } - if faltantes.any? - res.status = 400 - res.body = { error: "Faltan campos: #{faltantes.join(', ')}" }.to_json - return - end - - begin - Nexxa::Auth.crear_usuario(usuario: body['usuario'], password: body['password'], perfil: body['perfil']) - res.status = 201 - res.body = { ok: true, usuario: body['usuario'], perfil: body['perfil'] }.to_json - rescue RuntimeError => e - res.status = 409 - res.body = { error: e.message }.to_json - end - end - - def do_PATCH(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - usuario = usuario_de(req) - if usuario.empty? - res.status = 400 - res.body = { error: 'Uso: PATCH /usuarios/' }.to_json - return - end - - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.body = { error: 'JSON inválido' }.to_json - return - end - - # Guardia: no degradar/desactivar al último admin activo. - degradando = (body.key?('perfil') && body['perfil'] != 'admin') || body['activo'] == false - if degradando - actual = Nexxa::Auth.listar.find { |u| u['usuario'] == usuario } - if actual && actual['perfil'] == 'admin' && actual['activo'] != false && Nexxa::Auth.admins_activos <= 1 - res.status = 409 - res.body = { error: 'No se puede desactivar/degradar al último admin activo' }.to_json - return - end - end - - begin - entrada = Nexxa::Auth.actualizar( - usuario: usuario, - perfil: body['perfil'], - activo: body.key?('activo') ? body['activo'] : nil, - password_nueva: body['password'] - ) - res.status = 200 - res.body = entrada.to_json - rescue RuntimeError => e - res.status = 404 - res.body = { error: e.message }.to_json - end - end - - def do_DELETE(req, res) - return rechazar_no_autenticado(res) unless operador_autenticado?(req) - return rechazar_no_admin(res) unless admin_autenticado?(req) - - res.content_type = 'application/json' - usuario = usuario_de(req) - if usuario.empty? - res.status = 400 - res.body = { error: 'Uso: DELETE /usuarios/' }.to_json - return - end - - actual = Nexxa::Auth.listar.find { |u| u['usuario'] == usuario } - if actual && actual['perfil'] == 'admin' && actual['activo'] != false && Nexxa::Auth.admins_activos <= 1 - res.status = 409 - res.body = { error: 'No se puede eliminar al último admin activo' }.to_json - return - end - - borrado = Nexxa::Auth.eliminar(usuario) - if borrado - res.status = 200 - res.body = { ok: true }.to_json - else - res.status = 404 - res.body = { error: 'Usuario no encontrado' }.to_json - end - end -end - -server.mount '/usuarios', UsuariosServlet - -# GET /disponible/ — entrega el valor real al individuo autenticado -# (Regla 15: sistema-a-sistema, no exposición a un humano — D045 §8/§10). -# Cifrado de punta a punta (P204, ver empaquetar_valor/lib_envelope.rb): si el -# individuo registró clave pública (POST /consumidor/clave-publica), el -# valor va cifrado con SU clave — ni TLS ni NEXXA ven el texto plano en el -# cuerpo de la respuesta, solo el individuo con su privada. Sin clave -# registrada, cae a texto plano protegido solo por TLS (compatibilidad). -# POST /disponible//reportar — salud real de keys (P204/Fase3, D045 -# §8): el consumidor, no NEXXA, reporta si la key sigue sana, si la libera -# antes de tiempo, o si se agotó de verdad contra el proveedor real. -# P335/Fase 5: puede ser un ROL (mente|red) → el pool de ESE individuo, que mezcla proveedores; si no, es un -# provider como siempre. La decisión vive en Nexxa::Pools (disponible/proxima/estado), no acá. -server.mount_proc '/disponible' do |req, res| - individuo = individuo_autenticado(req) - if individuo.nil? - res.status = 401 - res.content_type = 'application/json' - res.body = { error: 'Token inválido o ausente (header Authorization: Bearer )' }.to_json - next - end - - resto = req.path.sub(%r{\A/disponible/?}, '') - - if req.request_method == 'POST' && resto.end_with?('/reportar') - nombre = resto.sub(%r{/reportar\z}, '') - if nombre.empty? - res.status = 400 - res.content_type = 'application/json' - res.body = { error: 'Uso: POST /disponible//reportar' }.to_json - next - end - - body = begin - JSON.parse(req.body.to_s) - rescue JSON::ParserError - {} - end - identificador = body['identificador'] - estado = body['estado'] - liberar_en_segundos = body['liberar_en_segundos'] - # En un rol el pool mezcla proveedores: la key se identifica con provider + identificador (la que se recibió). - provider = Nexxa::Pools.rol?(nombre) ? body['provider'].to_s : nombre - - unless identificador && !provider.empty? && %w[sana liberada agotada].include?(estado) - res.status = 400 - res.content_type = 'application/json' - res.body = { error: 'Body esperado: {identificador, estado: sana|liberada|agotada, liberar_en_segundos?, motivo?} ' \ - '(+ provider si se reporta por rol mente|red)' }.to_json - next - end - - begin - Nexxa::Registro.reportar( - provider: provider, identificador: identificador, individuo: individuo, - estado: estado, liberar_en_segundos: liberar_en_segundos, motivo: body['motivo'] - ) - rescue StandardError => e - res.status = 409 - res.content_type = 'application/json' - res.body = { error: e.message }.to_json - next - end - - resp = { provider: provider, identificador: identificador, estado: estado } - - if estado == 'agotada' - # Del mismo pool (rol) o del mismo provider, elegida y reservada en un solo paso atómico (P335/Fase 17) - siguiente = Nexxa::Pools.dispensar(individuo, nombre) - if siguiente&.dig('valor_cifrado') - valor_siguiente = Nexxa::Registro.descifrar(siguiente['valor_cifrado']) - resp[:siguiente] = { provider: siguiente['provider'], identificador: siguiente['identificador'] } - .merge(empaquetar_valor(individuo, valor_siguiente)) - end - end - - res.status = 200 - res.content_type = 'application/json' - res.body = resp.to_json - next - end - - # GET /disponible//estado (P334/Fase 4): estado del pool por key, nunca el valor. Mismo gate que el - # resto de /disponible (token de individuo, ME-683): solo metadata para diagnosticar. - if req.request_method == 'GET' && resto.end_with?('/estado') - nombre = resto.sub(%r{/estado\z}, '') - res.status = nombre.empty? ? 400 : 200 - res.content_type = 'application/json' - res.body = if nombre.empty? - { error: 'Uso: GET /disponible//estado' }.to_json - elsif Nexxa::Pools.rol?(nombre) - { individuo: individuo, rol: nombre, keys: Nexxa::Pools.estado(individuo, nombre) }.to_json - else - { provider: nombre, keys: Nexxa::Pools.estado(individuo, nombre) }.to_json - end - next - end - - nombre = resto - if nombre.empty? - res.status = 400 - res.content_type = 'application/json' - res.body = { error: 'Uso: GET /disponible/' }.to_json - next - end - - # Pool vacío: explícito, nunca cae al provider (el admin todavía no le asignó keys a ese individuo en ese rol) - if Nexxa::Pools.pool_vacio?(individuo, nombre) - res.status = 404 - res.content_type = 'application/json' - res.body = { error: 'pool_vacio', individuo: individuo, rol: nombre }.to_json - next - end - - donde = Nexxa::Pools.rol?(nombre) ? { rol: nombre } : { provider: nombre } - # Elegir y reservar en UN paso atómico (P335/Fase 17): antes se elegía y se reservaba después, y dos consumidores - # simultáneos podían recibir la misma key. dry_run solo mira, nunca reserva. - key = req.query['dry_run'] ? Nexxa::Pools.disponible(individuo, nombre) : Nexxa::Pools.dispensar(individuo, nombre) - if key.nil? - proxima = Nexxa::Pools.proxima(individuo, nombre) - res.status = 404 - res.content_type = 'application/json' - res.body = if proxima - { error: 'agotado', proxima_disponible: proxima['disponible_desde'] }.merge(donde).to_json - else - { error: 'sin_keys_registradas' }.merge(donde).to_json - end - next - end - provider = key['provider'] - - # dry_run (P204, prp08 §"verificar sin consumir"): confirmar disponibilidad sin - # dispensar el valor ni marcar uso — nunca incluye 'valor' en la respuesta, - # pensado para health-check/verificación (evita que probar el mecanismo - # requiera recibir el secreto — ver incidente de sesión, ME-631). - if req.query['dry_run'] - res.status = 200 - res.content_type = 'application/json' - res.body = { provider: provider, identificador: key['identificador'], disponible: true }.to_json - next - end - - valor = key['valor_cifrado'] && Nexxa::Registro.descifrar(key['valor_cifrado']) - if valor.nil? - # Key registrada solo como metadata (no migrada todavía, D045 §9→§10) — - # respuesta explícita, nunca silenciosa (mismo criterio que router.rb) - res.status = 409 - res.content_type = 'application/json' - res.body = { error: 'sin_valor_migrado', provider: provider, identificador: key['identificador'] }.to_json - next - end - - # La reserva corta de contención (P204/Fase3, D045 §8) ya la aplicó dispensar: no asume agotamiento (eso lo - # decide el consumidor vía POST .../reportar), solo evita que 2 consumidores reciban la misma key. - res.status = 200 - res.content_type = 'application/json' - res.body = { provider: provider, identificador: key['identificador'] }.merge(empaquetar_valor(individuo, valor)).to_json -end - -# POST /consumidor/clave-publica — cifrado de punta a punta (P204): el -# individuo registra SU PROPIA clave pública RSA (PEM), self-service — solo -# puede tocar la suya (individuo_autenticado la resuelve por su propio -# token, no hay parámetro "para quién" que alguien pueda falsear). La -# privada nunca llega a NEXXA, ni siquiera de paso — el individuo la genera -# y se la guarda él mismo, acá solo entra la mitad pública. -server.mount_proc '/consumidor/clave-publica' do |req, res| - individuo = individuo_autenticado(req) - if individuo.nil? - res.status = 401 - res.content_type = 'application/json' - res.body = { error: 'Token inválido o ausente (header Authorization: Bearer )' }.to_json - next - end - - if req.request_method != 'POST' - res.status = 405 - res.content_type = 'application/json' - res.body = { error: 'Uso: POST /consumidor/clave-publica {clave_publica: "-----BEGIN PUBLIC KEY-----..."}' }.to_json - next - end - - body = begin - JSON.parse(req.body.to_s) - rescue JSON::ParserError - {} - end - - begin - Nexxa::Tokens.registrar_clave_publica(individuo: individuo, clave_publica_pem: body['clave_publica'].to_s) - rescue StandardError => e - res.status = 400 - res.content_type = 'application/json' - res.body = { error: e.message }.to_json - next - end - - res.status = 200 - res.content_type = 'application/json' - res.body = { ok: true, individuo: individuo }.to_json -end - -# POST /alta — alta de una key nueva, JSON {provider, identificador, cuenta_origen, -# reset_segundos, valor}. Requiere perfil admin (operador es solo-lectura). -server.mount_proc '/alta' do |req, res| - if req.request_method != 'POST' - res.status = 405 - res.content_type = 'application/json' - res.body = { error: 'Método no permitido — usar POST' }.to_json - next - end - - unless operador_autenticado?(req) - rechazar_no_autenticado(res) - next - end - unless admin_autenticado?(req) - rechazar_no_admin(res) - next - end - - begin - body = JSON.parse(req.body) - rescue JSON::ParserError - res.status = 400 - res.content_type = 'application/json' - res.body = { error: 'JSON inválido' }.to_json - next - end - - faltantes = %w[provider identificador cuenta_origen reset_segundos valor].reject { |k| body[k] } - if faltantes.any? - res.status = 400 - res.content_type = 'application/json' - res.body = { error: "Faltan campos: #{faltantes.join(', ')}" }.to_json - next - end - - Nexxa::Registro.registrar( - provider: body['provider'], - identificador: body['identificador'], - cuenta_origen: body['cuenta_origen'], - reset_segundos: body['reset_segundos'].to_i, - valor: body['valor'], - por: quien(req) - ) - - res.status = 201 - res.content_type = 'application/json' - res.body = { ok: true, provider: body['provider'], identificador: body['identificador'] }.to_json -end - -# /checkin — reporte proactivo de estado de individuos F1 (P216). Mismo -# patrón de auth que /disponible: individuo_autenticado(req) — el token YA -# identifica quién reporta, nunca se confía en un id del body/path para -# escribir. Consultar (GET) exige token válido igual (cualquier consumidor -# logueado por Bearer, no solo el propio individuo) — es diagnóstico -# compartido entre el equipo F1, no un dato privado de cada uno. -server.mount_proc '/checkin' do |req, res| - individuo = individuo_autenticado(req) - if individuo.nil? - res.status = 401 - res.content_type = 'application/json' - res.body = { error: 'Token inválido o ausente (header Authorization: Bearer )' }.to_json - next - end - - resto = req.path.sub(%r{\A/checkin/?}, '') - - if req.request_method == 'POST' && resto.empty? - body = begin - JSON.parse(req.body.to_s) - rescue JSON::ParserError - {} - end - estado = body['estado'] - if estado.to_s.strip.empty? - res.status = 400 - res.content_type = 'application/json' - res.body = { error: "Uso: POST /checkin {estado: '...', detalle: '...' (opcional)}" }.to_json - next - end - - registro = Nexxa::Checkins.registrar(individuo, estado: estado, detalle: body['detalle']) - res.status = 201 - res.content_type = 'application/json' - res.body = { ok: true, individuo: individuo }.merge(registro).to_json - next - end - - if req.request_method == 'GET' && !resto.empty? - registro = Nexxa::Checkins.estado(resto) - if registro.nil? - res.status = 404 - res.content_type = 'application/json' - res.body = { error: "Sin check-in registrado para '#{resto}'" }.to_json - next - end - res.content_type = 'application/json' - res.body = { individuo: resto }.merge(registro).to_json - next - end - - res.status = 404 - res.content_type = 'application/json' - res.body = { error: 'Uso: POST /checkin (reportar propio estado) | GET /checkin/ (consultar)' }.to_json -end - -# /checkins (bulk) — P216/Fase4: todos los check-in en una sola respuesta, -# consumida por el FRONTEND del panel (cookie de sesión del Operador, mismo -# mecanismo que /consumidores — operador_autenticado?, NO individuo_autenticado -# que exige Bearer token de individuo F1). Bug real corregido en el camino: la -# primera versión exigía Bearer, el JS nunca lo manda, devolvía 401 en loop -# con el interceptor global de fetch que recarga la página en cualquier 401. -server.mount_proc '/checkins' do |req, res| - unless operador_autenticado?(req) - res.status = 401 - res.content_type = 'application/json' - res.body = { error: 'Sesión inválida o expirada' }.to_json - next - end - - res.content_type = 'application/json' - res.body = Nexxa::Checkins.listar.to_json -end - -trap('INT') { server.shutdown } -trap('TERM') { server.shutdown } -server.start diff --git a/servicios/nexxa/organismo/tool_humo_pool.rb b/servicios/nexxa/organismo/tool_humo_pool.rb deleted file mode 100644 index deb4ede9..00000000 --- a/servicios/nexxa/organismo/tool_humo_pool.rb +++ /dev/null @@ -1,239 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -# tool_humo_pool.rb — Pool de tests de humo: rotación + salud + mecanismo de -# reserva/reporte (P204/Fase3-4) -# ============================================================================== -# Formaliza las verificaciones ad-hoc hechas durante P204 (pedido del Operador: -# re-correrlas cuando se toque el mecanismo de nuevo, no reinventarlas cada -# vez). Corre LOCAL contra lib_registro.rb — sin pasar por HTTP/server.rb, mismo -# criterio que las pruebas aisladas de Fase 3. -# -# Todo lo destructivo (reserva, rotación, reportar) usa un provider/keys -# DESCARTABLES ('selftest', nunca un provider real) — nunca toca keys reales -# ni su estado. La única sección de solo-lectura ("salud actual") sí lee el -# registro real, pero nunca dispensa ni reserva nada (mismo espíritu que -# dry_run) — reporta el estado tal cual está, no lo cambia. -# ============================================================================== -# Uso: ruby tool_humo_pool.rb (correr como usuario 'nexxa' — dueño de -# registro.json — o con permisos de lectura/ -# escritura sobre él) -# ============================================================================== - -require_relative 'lib_registro' -require_relative 'lib_tokens' -require_relative 'lib_envelope' -require 'openssl' -require 'base64' - -PROVIDER_TEST = 'selftest' -INDIVIDUO_TEST = 'selftest' - -$fallas = 0 -$total = 0 - -def test(nombre) - $total += 1 - yield - puts " ✅ #{nombre}" -rescue StandardError => e - $fallas += 1 - puts " ❌ #{nombre} — #{e.class}: #{e.message}" -end - -def assert(cond, msg) - raise msg unless cond -end - -def limpiar_provider_test - Nexxa::Registro.leer['keys'] - .select { |k| k['provider'] == PROVIDER_TEST } - .each { |k| Nexxa::Registro.eliminar(provider: PROVIDER_TEST, identificador: k['identificador']) } -end - -puts "\n🧪 Pool de tests NEXXA — rotación + salud + reserva/reporte (P204)\n\n" - -# ------------------------------------------------------------------ -puts '→ Salud actual (solo lectura, keys REALES — nunca dispensa)' -ahora = Time.now -providers_reales = Nexxa::Registro.leer['keys'].map { |k| k['provider'] }.uniq - -test('lee el registro real sin explotar') do - assert(Nexxa::Registro.leer.is_a?(Hash), 'leer() no devolvió un Hash') -end - -providers_reales.each do |provider| - # El estado de la taxonomía única (Registro.estado_de, P337/Fase 1), nunca recalculado acá - Nexxa::Registro.estado_pool(provider, ahora).each do |k| - icono = { 'disponible' => '🟢', 'en_uso' => '🔵', 'en_pausa' => '🟡', 'agotada' => '🔴', 'desactivada' => '⚪', - 'sin_valor' => '▫️' }[k['estado']] - puts " #{icono} #{provider}/#{k['identificador']}: #{k['estado']}#{k['hasta'] ? " hasta #{k['hasta']}" : ''}" - end -end - -# ------------------------------------------------------------------ -puts "\n→ Mecanismo de reserva/reporte (provider descartable '#{PROVIDER_TEST}')" -limpiar_provider_test - -Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: 'k1', cuenta_origen: 'test', reset_segundos: 3) - -test('key recén registrada está disponible') do - assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'no debería estar nil') -end - -test('reservar bloquea la key para otros consumidores') do - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') - assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'sigue apareciendo disponible con reserva activa') -end - -test('reportar rechaza a un individuo que no tiene la reserva') do - begin - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testB', estado: 'sana') - raise 'no lanzó excepción' - rescue RuntimeError - # esperado - end -end - -test("estado 'sana' renueva la reserva (sigue no disponible)") do - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'sana') - assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería seguir reservada tras "sana"') -end - -test("estado 'liberada' libera de inmediato") do - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'liberada') - assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar disponible tras "liberada"') -end - -test("estado 'agotada' con liberar_en_segundos aplica el valor custom, no reset_segundos") do - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'agotada', liberar_en_segundos: 2) - assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería estar agotada inmediatamente después') - sleep 2.2 - assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería liberarse tras los 2s custom') -end - -test('reserva sin ningún reporte vence sola (pasivo)') do - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') - state = Nexxa::Registro.leer - entrada = state['keys'].find { |k| k['identificador'] == 'k1' } - entrada['reservado_hasta'] = (Time.now - 1).iso8601(3) - Nexxa::Registro.guardar(state) - assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar libre con reserva vencida') -end - -# ------------------------------------------------------------------ -puts "\n→ Rotación del pool (menos usada recientemente, no siempre la primera)" -limpiar_provider_test - -%w[k1 k2 k3].each { |id| Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: id, cuenta_origen: 'test', reset_segundos: 100) } - -# ultimo_uso explícito y bien separado (determinismo — 3 registrar() seguidos -# pueden empatar en el mismo milisegundo según qué tan rápido corra la CPU/ -# disco, sin relación con el mecanismo real que se está probando) -state = Nexxa::Registro.leer -base = Time.now - 30 -%w[k1 k2 k3].each_with_index do |id, i| - entrada = state['keys'].find { |k| k['provider'] == PROVIDER_TEST && k['identificador'] == id } - entrada['ultimo_uso'] = (base + i).iso8601(3) -end -Nexxa::Registro.guardar(state) - -test('6 pedidos seguidos rotan k1→k2→k3→k1→k2→k3, sin repetir de corrido') do - orden = [] - 6.times do - k = Nexxa::Registro.disponible(PROVIDER_TEST) - orden << k['identificador'] - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot') - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada') - # separación real entre picks — evita empates de milisegundo entre - # reservar() consecutivos en un loop apretado (nunca pasa en uso real: - # nadie dispensa+reporta 2 keys en el mismo milisegundo) - sleep 0.01 - end - esperado = %w[k1 k2 k3 k1 k2 k3] - assert(orden == esperado, "orden real: #{orden.join('→')} (esperado: #{esperado.join('→')})") -end - -test('una key agotada no entra en la rotación hasta liberarse') do - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot') - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot', estado: 'agotada', liberar_en_segundos: 999) - 3.times do - k = Nexxa::Registro.disponible(PROVIDER_TEST) - assert(k['identificador'] != 'k2', 'k2 no debería salir elegida estando agotada') - Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot') - Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada') - end -end - -limpiar_provider_test - -# ------------------------------------------------------------------ -puts "\n→ Cifrado de punta a punta (P204, envelope RSA-OAEP)" - -def limpiar_individuo_test - state = Nexxa::Tokens.leer - state['tokens'].reject! { |t| t['individuo'] == INDIVIDUO_TEST } - Nexxa::Tokens.guardar(state) -end - -limpiar_individuo_test -Nexxa::Tokens.generar(INDIVIDUO_TEST) -par_test = OpenSSL::PKey::RSA.generate(2048) - -test('registrar_clave_publica guarda y releer coincide exacto') do - Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: par_test.public_key.to_pem) - assert(Nexxa::Tokens.clave_publica(INDIVIDUO_TEST) == par_test.public_key.to_pem, 'la clave releída no coincide con la guardada') -end - -test('rechaza una clave pública inválida (no PEM)') do - begin - Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: 'no es una clave') - raise 'no lanzó excepción' - rescue RuntimeError - # esperado - end -end - -test('rechaza registrar clave para un individuo sin token') do - begin - Nexxa::Tokens.registrar_clave_publica(individuo: 'no-existe-de-verdad', clave_publica_pem: par_test.public_key.to_pem) - raise 'no lanzó excepción' - rescue RuntimeError - # esperado - end -end - -test('Envelope.cifrar_para produce algo distinto del valor real') do - valor = 'valor-de-prueba-no-es-un-secreto-real' - cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) - assert(cifrado != valor, 'el cifrado es igual al valor real — no cifró nada') -end - -test('round-trip: cifrar con la pública + descifrar con la privada = valor original') do - valor = 'valor-de-prueba-no-es-un-secreto-real' - cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) - descifrado = par_test.private_decrypt(Base64.strict_decode64(cifrado), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING) - assert(descifrado == valor, "descifrado (#{descifrado.inspect}) no coincide con el original") -end - -test('la clave pública sola NO alcanza para descifrar (asimetría real)') do - valor = 'valor-de-prueba-no-es-un-secreto-real' - cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) - begin - par_test.public_decrypt(Base64.strict_decode64(cifrado)) - raise 'se pudo descifrar solo con la pública — esto NO debería pasar' - rescue OpenSSL::PKey::RSAError - # esperado — confirma que es asimétrico de verdad - end -end - -test('sin clave pública registrada, empaquetar_valor cae a texto plano (compatibilidad)') do - assert(Nexxa::Tokens.clave_publica('individuo-sin-clave-nunca-registrada').nil?, 'debería ser nil para un individuo sin clave') -end - -limpiar_individuo_test - -# ------------------------------------------------------------------ -puts "\n#{$fallas.zero? ? '✅' : '❌'} #{$total - $fallas}/#{$total} tests OK\n\n" -exit($fallas.zero? ? 0 : 1) diff --git a/servicios/nexxa/test/estado_test.rb b/servicios/nexxa/test/estado_test.rb deleted file mode 100644 index ad085647..00000000 --- a/servicios/nexxa/test/estado_test.rb +++ /dev/null @@ -1,254 +0,0 @@ -# frozen_string_literal: true - -# estado_test.rb — Nexxa::Estado (P335/Fase 17): motor archivo con concurrencia REAL entre procesos y motor pg con una -# conexión simulada (no toca ningún Postgres). Corre sobre una COPIA de organismo/. ruby servicios/nexxa/test/estado_test.rb -require 'minitest/autorun' -require 'tmpdir' -require 'fileutils' -require 'json' -require 'stringio' - -DIR_ESTADO = Dir.mktmpdir('nexxa-estado') -Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_ESTADO) } -require File.join(DIR_ESTADO, 'lib_estado') -require File.join(DIR_ESTADO, 'lib_registro') -require File.join(DIR_ESTADO, 'lib_pools') -require File.join(DIR_ESTADO, 'cli_estado') -Minitest.after_run { FileUtils.rm_rf(DIR_ESTADO) } - -class EstadoArchivoTest < Minitest::Test - E = Nexxa::Estado - R = Nexxa::Registro - - def setup - ENV.delete('NEXXA_ESTADO') - FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '*.json')] + [Nexxa::Usos::LOG_FILE]) - end - - def test_sin_variable_el_motor_es_archivo_y_uno_invalido_falla - assert_equal 'archivo', E.motor - ENV['NEXXA_ESTADO'] = 'mongo' - assert_raises(ArgumentError) { E.motor } - ensure - ENV.delete('NEXXA_ESTADO') - end - - def test_guardar_es_0600_y_leer_devuelve_el_defecto_si_falta - ruta = File.join(DIR_ESTADO, 'x.json') - assert_equal({ 'a' => [] }, E.leer('x', ruta, { 'a' => [] })) - E.guardar('x', ruta, { 'a' => [1] }) - assert_equal '600', format('%o', File.stat(ruta).mode & 0o777) - assert_equal({ 'a' => [1] }, E.leer('x', ruta, {})) - end - - # La carrera que cierra la fase: 2 procesos x 50 incrementos sobre el mismo archivo no pierden ninguno - def test_mutar_no_pierde_escrituras_entre_procesos - ruta = File.join(DIR_ESTADO, 'contador.json') - pids = 2.times.map do - fork { 50.times { E.mutar('contador', ruta, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } } } - end - pids.each { |p| Process.wait(p) } - assert_equal 100, E.leer('contador', ruta, {})['n'] - end - - # Dispensa atómica: 6 procesos piden a la vez de un pool de 3 keys — nunca la misma key a dos, y 3 se quedan sin - def test_dispensar_nunca_entrega_la_misma_key_dos_veces - pasado = (Time.now - 3600).iso8601(3) - R.guardar('keys' => %w[k1 k2 k3].map do |i| - { 'provider' => 'p', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 60, 'valor_cifrado' => 'x' } - end) - lectores = 6.times.map do |n| - r, w = IO.pipe - pid = fork do - r.close - w.write(R.reservar_libre(individuo: "ind#{n}", provider: 'p')&.dig('identificador').to_s) - w.close - end - w.close - [pid, r] - end - entregadas = lectores.map { |pid, r| Process.wait(pid) && r.read.tap { r.close } }.reject(&:empty?) - assert_equal %w[k1 k2 k3], entregadas.sort - end - - def test_una_key_solo_metadata_se_devuelve_sin_reservar - R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'm', 'disponible_desde' => (Time.now - 60).iso8601(3) }]) - entrada = R.reservar_libre(individuo: 'i', provider: 'p') - assert_equal 'm', entrada['identificador'] - assert_nil R.leer['keys'].first['reservado_por'] - end - - # La hora de la próxima libre incluye la reserva: con todas reservadas, nunca una hora pasada (caso real 2026-10-05) - def test_proxima_considera_la_reserva - ahora = Time.now - R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'k', 'disponible_desde' => (ahora - 3600).iso8601(3), - 'reservado_por' => 'x', 'reservado_hasta' => (ahora + 600).iso8601(3) }]) - assert_operator Time.parse(R.proxima('p')['disponible_desde']), :>, ahora - assert_nil R.disponible('p') - end - - def test_usos_en_archivo_mas_reciente_primero - E.usos_registrar('provider' => 'p', 'identificador' => 'a', 'individuo' => 'i', 'evento' => 'dispensada', 'en' => '2026-10-05T01:00:00-03:00') - E.usos_registrar('provider' => 'p', 'identificador' => 'b', 'individuo' => 'i', 'evento' => 'agotada', 'en' => '2026-10-05T02:00:00-03:00') - assert_equal %w[b a], E.usos_historial.map { |u| u['identificador'] } - assert_equal ['a'], E.usos_historial(identificador: 'a').map { |u| u['identificador'] } - end -end - -# Conexión simulada con la forma de PG::Connection que usa Estado (exec, exec_params, transaction_status) -class ConexionFalsa - attr_reader :sql - - def initialize = (@filas = {}; @usos = []; @sql = []; @tx = 0) - def transaction_status = @tx - - def exec(q) - @sql << q - return [{ 'n' => @usos.size }] if q.start_with?('SELECT count(*)') - return @usos.map { |u| %w[provider identificador individuo evento en].zip(u).to_h } if q.include?('FROM usos ORDER BY id') - - @tx = 2 if q == 'BEGIN' - if %w[COMMIT ROLLBACK].include?(q) - @tx = 0 - @filas = @copia if q == 'ROLLBACK' && @copia - end - @copia = Marshal.load(Marshal.dump(@filas)) if q == 'BEGIN' - [] - end - - def exec_params(q, params) - @sql << q.split.first(2).join(' ') - case q - when /\AINSERT INTO usos/m then @usos << params - when /\AINSERT INTO estado .* DO NOTHING/m then @filas[params[0]] ||= params[1] - when /\AINSERT INTO estado/m, /\AUPDATE estado/m then @filas[params[0]] = params[1] - when /\ASELECT valor FROM estado/m then return @filas.key?(params[0]) ? [{ 'valor' => @filas[params[0]] }] : [] - end - [] - end -end - -class EstadoPgTest < Minitest::Test - E = Nexxa::Estado - - def setup - ENV['NEXXA_ESTADO'] = 'pg' - @c = ConexionFalsa.new - E.con = @c - end - - def teardown - ENV.delete('NEXXA_ESTADO') - E.con = nil - end - - def test_leer_guardar_por_clave_sin_tocar_archivos - assert_equal({ 'keys' => [] }, E.leer('registro', '/no/existe.json', { 'keys' => [] })) - E.guardar('registro', '/no/existe.json', { 'keys' => [1] }) - assert_equal({ 'keys' => [1] }, E.leer('registro', '/no/existe.json', {})) - end - - def test_mutar_hace_begin_commit_y_devuelve_el_valor_nuevo - nuevo = E.mutar('pools', nil, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } - assert_equal({ 'n' => 1 }, nuevo) - assert_equal 'BEGIN', @c.sql.first - assert_equal 'COMMIT', @c.sql.last - assert(@c.sql.any? { |q| q.include?('SELECT') }) - assert_equal 0, @c.transaction_status - end - - def test_un_error_en_el_bloque_hace_rollback_y_no_guarda - E.guardar('pools', nil, { 'n' => 5 }) - assert_raises(RuntimeError) { E.mutar('pools', nil, {}) { |_v| raise 'no' } } - assert_includes @c.sql, 'ROLLBACK' - assert_equal 0, @c.transaction_status - assert_equal({ 'n' => 5 }, E.leer('pools', nil, {})) - end - - def salida_no_local - E.mutar('pools', nil, {}) { |_v| return :afuera } - end - - def test_un_return_en_el_bloque_no_deja_la_transaccion_abierta - assert_equal :afuera, salida_no_local - assert_equal 'ROLLBACK', @c.sql.last - assert_equal 0, @c.transaction_status - end -end - -class CliEstadoTest < Minitest::Test - E = Nexxa::Estado - C = Nexxa::CliEstado - - def setup - ENV.delete('NEXXA_ESTADO') - FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '{*.json,.*.json,*.tgz}')] + [E::USOS_LOG]) - E.con = ConexionFalsa.new - C.instance_variable_set(:@usos_archivo, nil) - E.archivo_guardar(E.ruta('registro'), { 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }) - E.archivo_guardar(E.ruta('usuarios'), [{ 'usuario' => 'admin' }]) - File.write(E::USOS_LOG, %({"provider":"p","identificador":"k1","individuo":"i","evento":"dispensada","en":"2026-10-05T01:00:00-03:00"}\n)) - end - - def teardown - E.con = nil - end - - def corre(accion) - out = StringIO.new - [C.call(accion, salida: out), out.string] - end - - def test_migrar_es_idempotente_y_respalda_antes_de_escribir - codigo, texto = corre('migrar') - assert_equal 0, codigo, texto - assert_match(/registro: migrada/, texto) - assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size - assert_equal({ 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }, E.pg_leer('registro', nil)) - - codigo2, texto2 = corre('migrar') - assert_equal 0, codigo2 - assert_match(/igual: pg ya coincide/, texto2) - assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size, 'la segunda corrida no respalda ni escribe' - end - - # Caso real 2026-10-05 02:43: usos.log de antes de P204/Fase 3 sin 'evento' frenó la activación (columna NOT NULL) - def test_migrar_completa_el_evento_de_los_usos_viejos - File.write(E::USOS_LOG, %({"provider":"p","identificador":"k0","individuo":"i","en":"2026-05-01T10:00:00-03:00"}\n), mode: 'a') - C.instance_variable_set(:@usos_archivo, nil) - codigo, texto = corre('migrar') - assert_equal 0, codigo, texto - eventos = E.con.instance_variable_get(:@usos).map { |u| u[3] } - assert_equal %w[dispensada dispensada], eventos - end - - def test_migrar_se_niega_con_el_motor_pg_ya_activo - dropin = File.join(DIR_ESTADO, 'estado.conf') - File.write(dropin, "[Service]\nEnvironment=NEXXA_ESTADO=pg\n") - out = StringIO.new - assert_equal 1, C.migrar(out, dropin: dropin) - assert_match(/ya está activo/, out.string) - assert_nil E.pg_leer('registro', nil), 'no escribió nada' - ensure - FileUtils.rm_f(dropin) - end - - def test_verificar_detecta_una_diferencia - corre('migrar') - E.archivo_guardar(E.ruta('pools'), { 'individuos' => { 'gemma' => { 'mente' => ['p/k1'] } } }) - codigo, texto = corre('verificar') - assert_equal 1, codigo - assert_match(/difiere de los archivos en: pools/, texto) - end - - def test_exportar_es_la_vuelta_atras - corre('migrar') - E.pg_guardar('registro', { 'keys' => [] }) - FileUtils.rm_f(E::USOS_LOG) - codigo, texto = corre('exportar') - assert_equal 0, codigo, texto - assert_equal({ 'keys' => [] }, E.archivo_leer(E.ruta('registro'), nil)) - assert_equal 1, File.readlines(E::USOS_LOG).size - end -end - diff --git a/servicios/nexxa/test/humo_http_test.rb b/servicios/nexxa/test/humo_http_test.rb deleted file mode 100644 index 3c3cbebc..00000000 --- a/servicios/nexxa/test/humo_http_test.rb +++ /dev/null @@ -1,177 +0,0 @@ -# frozen_string_literal: true - -# humo_http_test.rb — Humo HTTP REAL del server de NEXXA sobre una copia aislada (P335/Fase 5). -# El server de prueba lo arma lib_servidor_prueba.rb (copia aislada, estado falso, 127.0.0.1). Nunca toca el nodo -# ni secretos reales. Correr después de cada cambio de la API: ruby servicios/nexxa/test/humo_http_test.rb -require 'minitest/autorun' -require 'net/http' -require 'json' -require 'time' -require_relative 'lib_servidor_prueba' - -PRUEBA = ServidorPrueba.armar(individuos: %w[gemma-humo liberar-humo]) -PUERTO = PRUEBA[:puerto] -TOKEN_IND = PRUEBA[:tokens]['gemma-humo'] -TOKEN_LIB = PRUEBA[:tokens]['liberar-humo'] # individuo propio del test de liberar: no comparte estado -BASE_NEXXA_ORG = File.join(ServidorPrueba::BASE, 'organismo') -PID = ServidorPrueba.arrancar(PRUEBA) -Minitest.after_run { ServidorPrueba.detener(PID, PRUEBA) } - -# El server invalida las sesiones al arrancar (P204): se entra por /login, como un usuario real. -def login(usuario) - password = ServidorPrueba::USUARIOS.fetch(usuario).first - r = Net::HTTP.post(URI("http://127.0.0.1:#{PUERTO}/login"), { usuario: usuario, password: password }.to_json, - 'Content-Type' => 'application/json') - r['Set-Cookie'].to_s[/nexxa_session=([0-9a-f]+)/, 1] or raise "login de #{usuario} falló: #{r.code} #{r.body}" -end -SES_ADMIN = login('humo-admin') -SES_OPER = login('humo-oper') - -class HumoHttpTest < Minitest::Test - def pedir(metodo, ruta, cuerpo: nil, sesion: nil, token: nil) - req = Net::HTTP.const_get(metodo.capitalize).new(ruta) - req['Cookie'] = "nexxa_session=#{sesion}" if sesion - req['Authorization'] = "Bearer #{token}" if token - if cuerpo - req['Content-Type'] = 'application/json' - req.body = cuerpo.to_json - end - r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) } - [r.code.to_i, (JSON.parse(r.body) rescue r.body)] - end - - def test_ciclo_pools_y_disponible_por_rol - # sin pool asignado: explícito, nunca cae al provider - assert_equal [404, 'pool_vacio'], pedir('get', '/disponible/mente', token: TOKEN_IND).then { |c, b| [c, b['error']] } - # operador lee pero no asigna; admin asigna - assert_equal 403, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_OPER)[0] - assert_equal 200, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_ADMIN)[0] - assert_equal 200, pedir('post', '/pools/gemma-humo/red', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0] - assert_equal 400, pedir('post', '/pools/gemma-humo/otro', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0] - c, b = pedir('get', '/pools', sesion: SES_OPER) - assert_equal [200, ['d-01']], [c, b.dig('individuos', 'gemma-humo', 'mente').map { |f| f['identificador'] }] - - # mente y red dispensan su propia key, con el provider real - c, b = pedir('get', '/disponible/mente', token: TOKEN_IND) - assert_equal [200, 'deepseek', 'd-01'], [c, b['provider'], b['identificador']] - c, b = pedir('get', '/disponible/red?dry_run=1', token: TOKEN_IND) - assert_equal [200, 'gemini', 'g-02'], [c, b['provider'], b['identificador']] - - # reportar por rol exige provider; con provider marca agotada con motivo y el estado lo muestra - assert_equal 400, pedir('post', '/disponible/mente/reportar', cuerpo: { identificador: 'd-01', estado: 'agotada' }, token: TOKEN_IND)[0] - c, = pedir('post', '/disponible/mente/reportar', cuerpo: { provider: 'deepseek', identificador: 'd-01', estado: 'agotada', motivo: 'humo' }, token: TOKEN_IND) - assert_equal 200, c - c, b = pedir('get', '/disponible/mente/estado', token: TOKEN_IND) - assert_equal [200, 'mente', %w[agotada humo]], [c, b['rol'], b['keys'][0].values_at('estado', 'motivo')] - assert_equal 'agotado', pedir('get', '/disponible/mente', token: TOKEN_IND)[1]['error'] - - # compatibilidad: por provider sigue como antes - c, b = pedir('get', '/disponible/gemini?dry_run=1', token: TOKEN_IND) - assert_equal [200, 'gemini'], [c, b['provider']] - - # quitar (admin) y borrar una key la saca de todos los pools - assert_equal 200, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0] - assert_equal 404, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0] - assert_equal 200, pedir('delete', '/keys/gemini/g-02', sesion: SES_ADMIN)[0] - assert_equal({}, pedir('get', '/pools', sesion: SES_OPER)[1]['individuos']) - end - - def test_liberar_desde_la_web_solo_admin - # key (groq) e individuo propios: este test no toca nada de lo que usa el ciclo de pools - assert_equal 200, pedir('get', '/disponible/groq', token: TOKEN_LIB)[0] - pedir('post', '/disponible/groq/reportar', cuerpo: { identificador: 'q-lib', estado: 'agotada', motivo: 'humo-web' }, token: TOKEN_LIB) - key = -> { pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'q-lib' } } - assert_equal %w[liberar-humo humo-web], key.call.values_at('agotada_por', 'motivo_agotada') - assert_equal 'agotado', pedir('get', '/disponible/groq', token: TOKEN_LIB)[1]['error'] - assert_equal 403, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_OPER)[0] - assert_equal 404, pedir('post', '/keys/groq/no-existe/liberar', sesion: SES_ADMIN)[0] - assert_equal 200, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_ADMIN)[0] - assert_equal [nil, nil], key.call.values_at('agotada_por', 'motivo_agotada') - assert_equal 200, pedir('get', '/disponible/groq?dry_run=1', token: TOKEN_LIB)[0] - end - - # Fase 12: CRUD completo (individuo propio 'crud-humo', se deja vacío al final: no interfiere con los otros tests) - def test_crud_editar_mover_vaciar_y_pools_por_key - base = '/pools/crud-humo/mente' - assert_equal 403, pedir('put', base, cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_OPER)[0] - c, b = pedir('put', base, cuerpo: { refs: %w[gemini/g-01 deepseek/d-01] }, sesion: SES_ADMIN) - assert_equal [200, %w[gemini/g-01 deepseek/d-01]], [c, b['pool']] - # una ref mala: 400 y no cambia nada - assert_equal 400, pedir('put', base, cuerpo: { refs: %w[gemini/g-01 gemini/no-existe] }, sesion: SES_ADMIN)[0] - assert_equal 400, pedir('put', base, cuerpo: { otra: 1 }, sesion: SES_ADMIN)[0] - filas = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo', 'mente').map { |f| f['identificador'] } - assert_equal %w[g-01 d-01].sort, filas.sort - # la key sabe en qué pools está - g01 = pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'g-01' } - assert_includes g01['pools'], { 'individuo' => 'crud-humo', 'rol' => 'mente' } - # mover al otro rol - c, b = pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN) - assert_equal [200, 'red'], [c, b['a']] - assert_equal 400, pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN)[0] # ya no está en mente - # vaciar los dos roles - assert_equal 200, pedir('put', base, cuerpo: { refs: [] }, sesion: SES_ADMIN)[0] - assert_equal 200, pedir('put', '/pools/crud-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0] - assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo') - end - - # Fase 12: Individuos con resumen de pools; revocar borra sus pools (individuo propio, creado y revocado acá) - def test_individuos_con_pools_y_revocar_los_limpia - assert_equal 201, pedir('post', '/consumidores', cuerpo: { individuo: 'revocar-humo' }, sesion: SES_ADMIN)[0] - assert_equal 200, pedir('put', '/pools/revocar-humo/mente', cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_ADMIN)[0] - c = pedir('get', '/consumidores', sesion: SES_OPER)[1].find { |x| x['individuo'] == 'revocar-humo' } - assert_equal({ 'total' => 1, 'disponibles' => 1 }, c.dig('pools', 'mente')) - assert_equal({ 'total' => 0, 'disponibles' => 0 }, c.dig('pools', 'red')) - assert_equal 200, pedir('delete', '/consumidores/revocar-humo', sesion: SES_ADMIN)[0] - assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'revocar-humo') - end - - # Cache busting: el HTML referencia js/css con ?v= y no se cachea (P335: app.js viejo dejaba Pools vacío) - def test_html_trae_estaticos_con_version_y_no_se_cachea - version = File.read(File.join(BASE_NEXXA_ORG, 'VERSION')).strip - r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get('/') } # sin sesión: login.html - assert_includes r.body, "/css/estilos.css?v=#{version}" - assert_includes r.body, "/js/login.js?v=#{version}" - assert_equal 'no-cache', r['Cache-Control'] - req = Net::HTTP::Get.new('/') - req['Cookie'] = "nexxa_session=#{SES_OPER}" - r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) } # con sesión: index.html - assert_includes r.body, "/js/app.js?v=#{version}" - assert_equal 200, Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get("/js/app.js?v=#{version}") }.code.to_i - end - - # P337/Fase 1: estado calculado en /keys, registro filtrable y resumen, por HTTP y con el locale C del nodo - def test_estado_registro_y_resumen_por_http - keys = pedir('get', '/keys', sesion: SES_OPER)[1] - assert(keys.all? { |k| %w[disponible en_uso en_pausa agotada desactivada sin_valor].include?(k['estado']) }) - refute(keys.any? { |k| k.key?('valor_cifrado') }) - cod, usos = pedir('get', '/usos?evento=alta&horas=24', sesion: SES_OPER) - assert_equal 200, cod - assert(usos.all? { |u| u['evento'] == 'alta' }) - cod, res = pedir('get', '/resumen?horas=24', sesion: SES_OPER) - assert_equal 200, cod - assert_equal keys.size, res['ahora'].values.sum - assert_equal 401, pedir('get', '/resumen')[0] - end - - # Fase 13: renombrar una key (key propia d-ren; vuelve a su nombre al final) - def test_renombrar_key_actualiza_pools_y_valida - assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: %w[deepseek/d-ren] }, sesion: SES_ADMIN)[0] - assert_equal 403, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2' }, sesion: SES_OPER)[0] - assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'D REN' }, sesion: SES_ADMIN)[0] - assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-01' }, sesion: SES_ADMIN)[0] - assert_equal 404, pedir('patch', '/keys/deepseek/no-existe', cuerpo: { identificador: 'x' }, sesion: SES_ADMIN)[0] - c, b = pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2', cuenta_origen: 'otra' }, sesion: SES_ADMIN) - assert_equal [200, 'd-ren2', 'otra'], [c, b['identificador'], b['cuenta_origen']] - refs = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'ren-humo', 'red').map { |f| f['identificador'] } - assert_equal ['d-ren2'], refs - assert pedir('get', '/usos', sesion: SES_OPER)[1].to_a.any? { |u| u['evento'] == 'renombrada' && u['motivo'] == 'antes d-ren' } - # limpieza: vuelve a su nombre y se vacía el pool - assert_equal 200, pedir('patch', '/keys/deepseek/d-ren2', cuerpo: { identificador: 'd-ren' }, sesion: SES_ADMIN)[0] - assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0] - end - - def test_sin_token_ni_sesion - assert_equal 401, pedir('get', '/disponible/mente')[0] - assert_equal 401, pedir('get', '/pools')[0] - end -end diff --git a/servicios/nexxa/test/lib_servidor_prueba.rb b/servicios/nexxa/test/lib_servidor_prueba.rb deleted file mode 100644 index 8af8847b..00000000 --- a/servicios/nexxa/test/lib_servidor_prueba.rb +++ /dev/null @@ -1,60 +0,0 @@ -# frozen_string_literal: true - -# lib_servidor_prueba.rb — NEXXA de PRUEBA sobre una copia aislada (P335/Fase 7). Fuente única para el humo HTTP y para -# mirar nexxa-web en un navegador real sin tocar el nodo ni secretos reales. -# Copia organismo/ y web/ a un directorio temporal, cambia el server a 127.0.0.1 y un puerto libre, y siembra estado -# FALSO: master key, keys con valores inventados, usuarios humo-admin/humo-oper y tokens de individuos. -require 'tmpdir' -require 'fileutils' -require 'socket' - -module ServidorPrueba - BASE = File.expand_path('..', __dir__) - USUARIOS = { 'humo-admin' => ['humo-admin-123', 'admin'], 'humo-oper' => ['humo-oper-123', 'operador'] }.freeze - KEYS = [%w[gemini g-01], %w[gemini g-02], %w[deepseek d-01], %w[groq q-lib], %w[deepseek d-ren]].freeze - - module_function - - # => { dir:, org:, puerto:, tokens: { individuo => token } } - def armar(individuos: %w[gemma-humo liberar-humo], puerto: nil) - dir = Dir.mktmpdir('nexxa-prueba') - %w[organismo web].each { |d| FileUtils.cp_r(File.join(BASE, d), dir) } - org = File.join(dir, 'organismo') - puerto ||= TCPServer.new('127.0.0.1', 0).then { |s| s.addr[1].tap { s.close } } - srv = File.read(File.join(org, 'server.rb')) - .sub(/^PORT = \d+/, "PORT = #{puerto}").sub("BindAddress: '0.0.0.0'", "BindAddress: '127.0.0.1'") - File.write(File.join(org, 'server.rb'), srv) - - %w[lib_cripto lib_registro lib_tokens lib_auth lib_pools].each { |f| require File.join(org, f) } - Nexxa::MasterKey.generar_si_falta! - KEYS.each do |p, i| - Nexxa::Registro.registrar(provider: p, identificador: i, cuenta_origen: 'prueba', reset_segundos: 86_400, valor: "falso-#{i}", por: 'prueba') - end - USUARIOS.each { |u, (pw, perfil)| Nexxa::Auth.crear_usuario(usuario: u, password: pw, perfil: perfil) } - tokens = individuos.to_h { |ind| [ind, Nexxa::Tokens.generar(ind)] } - { dir: dir, org: org, puerto: puerto, tokens: tokens } - end - - # Arranca server.rb de la copia y espera el puerto. => pid - def arrancar(prueba, log: File.join(prueba[:dir], 'server.log')) - # Locale C como systemd en el nodo: un File.read sin encoding explícito falla acá igual que en producción (1.4.1) - pid = Process.spawn({ 'LC_ALL' => 'C', 'LANG' => 'C' }, 'ruby', 'server.rb', chdir: prueba[:org], out: File::NULL, err: log) - 60.times { abierto?(prueba[:puerto]) ? break : sleep(0.25) } - raise "El server de prueba no abrió el puerto #{prueba[:puerto]} (ver #{log})" unless abierto?(prueba[:puerto]) - - pid - end - - def detener(pid, prueba) - Process.kill('TERM', pid) rescue nil - Process.wait(pid) rescue nil - FileUtils.rm_rf(prueba[:dir]) - end - - def abierto?(puerto) - TCPSocket.new('127.0.0.1', puerto).close - true - rescue SystemCallError - false - end -end diff --git a/servicios/nexxa/test/pools_test.rb b/servicios/nexxa/test/pools_test.rb deleted file mode 100644 index 6b1909cb..00000000 --- a/servicios/nexxa/test/pools_test.rb +++ /dev/null @@ -1,144 +0,0 @@ -# frozen_string_literal: true - -# pools_test.rb — Pools por individuo (P335/Fase 4). Corre sobre una COPIA de organismo/ en un directorio temporal: -# registro.json/pools.json de prueba, nunca los reales. ruby servicios/nexxa/test/pools_test.rb -require 'minitest/autorun' -require 'tmpdir' -require 'fileutils' - -DIR_PRUEBA = Dir.mktmpdir('nexxa-pools') -Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_PRUEBA) } -require File.join(DIR_PRUEBA, 'lib_registro') -require File.join(DIR_PRUEBA, 'lib_pools') -Minitest.after_run { FileUtils.rm_rf(DIR_PRUEBA) } - -class PoolsTest < Minitest::Test - R = Nexxa::Registro - P = Nexxa::Pools - - def setup - FileUtils.rm_f([R::STATE_FILE, P::STATE_FILE]) - pasado = (Time.now - 3600).iso8601(3) - key = ->(p, i, extra = {}) { { 'provider' => p, 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'valor_cifrado' => 'x' }.merge(extra) } - R.guardar('keys' => [key.('gemini', 'g-01', 'ultimo_uso' => (Time.now - 60).iso8601(3)), - key.('deepseek', 'd-01', 'ultimo_uso' => (Time.now - 600).iso8601(3)), - key.('gemini', 'g-red'), - key.('gemini', 'g-off', 'activo' => false)]) - end - - def asignar(ind, rol, p, i) = P.asignar(individuo: ind, rol: rol, provider: p, identificador: i) - - def test_pool_mezcla_proveedores_y_da_la_menos_usada - asignar('gemma', 'mente', 'gemini', 'g-01') - asignar('gemma', 'mente', 'deepseek', 'd-01') - k = R.disponible_en(P.refs('gemma', 'mente')) - assert_equal %w[deepseek d-01], [k['provider'], k['identificador']] - end - - def test_red_separada_de_mente_y_compartida_entre_individuos - asignar('gemma', 'mente', 'gemini', 'g-01') - asignar('gemma', 'red', 'gemini', 'g-red') - asignar('peggy', 'red', 'gemini', 'g-red') - assert_equal 'g-red', R.disponible_en(P.refs('gemma', 'red'))['identificador'] - assert_equal [{ 'individuo' => 'gemma', 'rol' => 'red' }, { 'individuo' => 'peggy', 'rol' => 'red' }], - P.de_key('gemini', 'g-red') - end - - def test_asignar_es_idempotente_y_valida - 2.times { asignar('gemma', 'mente', 'gemini', 'g-01') } - assert_equal ['gemini/g-01'], P.refs('gemma', 'mente') - assert_raises(RuntimeError) { asignar('gemma', 'otro', 'gemini', 'g-01') } - assert_raises(RuntimeError) { asignar('gemma', 'mente', 'gemini', 'no-existe') } - end - - def test_desactivada_o_reservada_no_se_da_y_proxima_responde - asignar('gemma', 'mente', 'gemini', 'g-off') - assert_nil R.disponible_en(P.refs('gemma', 'mente')) - assert_nil R.proxima_en(P.refs('gemma', 'mente')) - asignar('gemma', 'mente', 'gemini', 'g-01') - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma') - assert_nil R.disponible_en(P.refs('gemma', 'mente')) - assert_equal 'g-01', R.proxima_en(P.refs('gemma', 'mente'))['identificador'] - end - - def test_quitar_y_olvidar_no_dejan_refs_colgadas - asignar('gemma', 'mente', 'gemini', 'g-01') - asignar('peggy', 'red', 'gemini', 'g-01') - assert P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01') - refute P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01') - assert P.olvidar_key(provider: 'gemini', identificador: 'g-01') - assert_equal({ 'individuos' => {} }, P.leer) - assert_equal '600', format('%o', File.stat(P::STATE_FILE).mode & 0o777) - end - - def test_pool_vacio_no_cae_al_provider - assert_nil R.disponible_en(P.refs('nadie', 'mente')) - assert P.pool_vacio?('nadie', 'mente') - assert_nil P.disponible('nadie', 'mente') - end - - # --- Fase 5: selección por nombre (rol o provider) y estado - def test_nombre_rol_usa_el_pool_y_nombre_provider_sigue_igual - asignar('gemma', 'mente', 'deepseek', 'd-01') - assert_equal 'd-01', P.disponible('gemma', 'mente')['identificador'] - assert_equal 'gemini', P.disponible('gemma', 'gemini')['provider'] # compatibilidad: por provider, sin pools - refute P.pool_vacio?('gemma', 'gemini') - refute P.rol?('gemini') - end - - def test_estado_por_rol_trae_provider_motivo_y_quien - asignar('gemma', 'mente', 'gemini', 'g-01') - asignar('gemma', 'mente', 'deepseek', 'd-01') - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma', estado: 'agotada', motivo: 'cuota diaria') - filas = P.estado('gemma', 'mente').to_h { |f| [f['identificador'], f] } - assert_equal %w[d-01 g-01], filas.keys.sort - assert_equal %w[agotada gemini gemma cuota\ diaria], - filas['g-01'].values_at('estado', 'provider', 'por', 'motivo') - assert_equal 'disponible', filas['d-01']['estado'] - assert_equal 'deepseek', P.disponible('gemma', 'mente')['provider'] - end - - def test_con_estado_para_la_web - asignar('gemma', 'red', 'gemini', 'g-red') - assert_equal ['g-red'], P.con_estado.dig('gemma', 'red').map { |f| f['identificador'] } - end - - # --- Fase 12: CRUD completo - def test_reemplazar_deja_el_pool_exacto_y_valida_todo_antes - asignar('gemma', 'mente', 'gemini', 'g-01') - assert_equal %w[deepseek/d-01 gemini/g-red], P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[deepseek/d-01 gemini/g-red]) - assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente') - assert_raises(RuntimeError) { P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[gemini/g-01 gemini/no-existe]) } - assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente') # nada cambió - P.reemplazar(individuo: 'gemma', rol: 'mente', refs: []) - assert_equal({ 'individuos' => {} }, P.leer) - end - - def test_mover_entre_roles - asignar('gemma', 'mente', 'gemini', 'g-01') - assert_equal 'red', P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01') - assert_equal [], P.refs('gemma', 'mente') - assert_equal ['gemini/g-01'], P.refs('gemma', 'red') - assert_raises(RuntimeError) { P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01') } - end - - # --- Fase 13: renombrar - def test_renombrar_actualiza_registro_y_pools - asignar('gemma', 'mente', 'gemini', 'g-01') - asignar('peggy', 'red', 'gemini', 'g-01') - R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno') - assert P.renombrar_key(provider: 'gemini', de: 'g-01', a: 'g-uno') - assert_equal ['gemini/g-uno'], P.refs('gemma', 'mente') - assert_equal ['gemini/g-uno'], P.refs('peggy', 'red') - assert R.todas.any? { |k| k['identificador'] == 'g-uno' } - end - - def test_renombrar_rechaza_invalido_existente_y_reservada - assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'G 01') } - assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-red') } - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma') - e = assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno') } - assert_match(/reservada por gemma/, e.message) - end -end diff --git a/servicios/nexxa/test/revertir_test.rb b/servicios/nexxa/test/revertir_test.rb deleted file mode 100644 index 14ab8d77..00000000 --- a/servicios/nexxa/test/revertir_test.rb +++ /dev/null @@ -1,102 +0,0 @@ -# frozen_string_literal: true - -# revertir_test.rb — Revertir el 'agotada' propio y estado del pool por key (P334/Fase 4, integrado en P335/Fase 6). -# Corre sobre una COPIA de organismo/ en un directorio temporal: nunca el registro real. -# ruby servicios/nexxa/test/revertir_test.rb -require 'minitest/autorun' -require 'tmpdir' -require 'fileutils' - -DIR_REVERTIR = Dir.mktmpdir('nexxa-revertir') -Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_REVERTIR) } -require File.join(DIR_REVERTIR, 'lib_registro') -Minitest.after_run { FileUtils.rm_rf(DIR_REVERTIR) } - -class RevertirTest < Minitest::Test - R = Nexxa::Registro - def setup - FileUtils.rm_f([R::STATE_FILE, Nexxa::Usos::LOG_FILE]) - pasado = (Time.now - 3600).iso8601(3) - R.guardar('keys' => %w[g-01 g-02 g-03].map { |i| { 'provider' => 'gemini', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'reservado_por' => nil, 'valor_cifrado' => 'x' } } + - [{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado, 'valor_cifrado' => 'x' }, - { 'provider' => 'gemini', 'identificador' => 'g-meta', 'disponible_desde' => pasado }]) - end - - def test_quien_la_agoto_puede_deshacerlo_aunque_ya_no_la_tenga_reservada - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada') - assert_equal 'agotada', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' }['estado'] - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'liberada') - e = R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' } - assert_equal 'disponible', e['estado'] - assert_includes File.read(Nexxa::Usos::LOG_FILE), 'revertida' - end - - def test_otro_individuo_no_puede_liberar_lo_que_agoto_otro - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada') - assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'peggy-f1', estado: 'liberada') } - end - - def test_el_flujo_original_de_reserva_sigue_igual - R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1') - assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'otro', estado: 'sana') } - R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'liberada') - assert_equal 'disponible', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-02' }['estado'] - end - - # Taxonomía cerrada (P337/Fase 1): un bloqueo de 60 s es una PAUSA por límite, uno largo es AGOTADA; sin valor y - # desactivada se distinguen; campos uniformes hasta/por/motivo - def test_estado_del_pool_sin_valores_y_con_la_taxonomia_completa - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1') - R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429') - R.reservar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1', estado: 'agotada', motivo: 'cuota diaria') - est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] } - assert_equal %w[en_uso en_pausa agotada desactivada sin_valor], %w[g-01 g-02 g-03 g-off g-meta].map { |i| est[i]['estado'] } - assert_equal %w[gemma-f1 429], est['g-02'].values_at('por', 'motivo') - assert_operator Time.parse(est['g-02']['hasta']), :>, Time.now - assert_equal 'gemma-f1', est['g-01']['por'] - refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') } - end - - # Registro completo: cada paso queda con su evento, motivo y hasta - def test_el_registro_anota_cada_paso - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'sana') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429 por minuto') - R.actualizar(provider: 'gemini', identificador: 'g-03', activo: false, por: 'web:admin') - R.eliminar(provider: 'gemini', identificador: 'g-off', por: 'web:admin') - h = Nexxa::Usos.historial - assert_equal %w[baja editada pausada renovada dispensada], h.map { |u| u['evento'] } - assert_equal '429 por minuto', h[2]['motivo'] - refute_nil h[2]['hasta'] - assert_equal 'activo: nil → false', h[1]['motivo'] - assert_equal ['web:admin'], Nexxa::Usos.historial(individuo: 'web:admin', evento: 'baja').map { |u| u['individuo'] } - end - - def test_resumen_cuenta_todos_los_estados_y_los_eventos_de_la_ventana - R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1') - R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60) - r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24) - assert_equal R::ESTADOS.sort, r['ahora'].keys.sort, 'todos los estados, también los que están en 0' - assert_equal 1, r['ahora']['en_pausa'] - assert_equal 0, r['ahora']['en_uso'] - assert_equal({ 'dispensada' => 1, 'pausada' => 1 }, r['eventos'].select { |_, n| n.positive? }) - g01 = r['por_key'].find { |k| k['identificador'] == 'g-01' } - assert_equal 'pausada', g01['ultimo_evento']['evento'] - refute r['por_key'].any? { |k| k.key?('valor_cifrado') } - end - - # Un 'agotada' anterior a 2.0.0 (sin hasta) no infla los agotamientos de cuota: se cuenta aparte, con su texto - def test_un_agotada_previo_a_2_0_0_se_cuenta_aparte - Nexxa::Usos.registrar(provider: 'gemini', identificador: 'g-01', individuo: 'x', evento: 'agotada') - r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24) - assert_equal 0, r['eventos']['agotada'] - assert_equal 1, r['eventos']['agotada-previa'] - u = Nexxa::Usos.historial.first - assert_equal 'agotada-previa', u['clase'] - assert_match(/anterior a 2\.0\.0/, u['texto']) - end -end diff --git a/servicios/nexxa/test/servidor_prueba.rb b/servicios/nexxa/test/servidor_prueba.rb deleted file mode 100644 index deb56975..00000000 --- a/servicios/nexxa/test/servidor_prueba.rb +++ /dev/null @@ -1,16 +0,0 @@ -# frozen_string_literal: true - -# servidor_prueba.rb — Deja corriendo un NEXXA de PRUEBA (copia aislada, estado falso) para mirar nexxa-web en un -# navegador real (P335/Fase 7). Ctrl+C lo detiene y borra la copia. -# ruby servicios/nexxa/test/servidor_prueba.rb [--puerto 14568] -# Entra con humo-admin / humo-admin-123 (o humo-oper / humo-oper-123): usuarios INVENTADOS de la copia, no del nodo. -require_relative 'lib_servidor_prueba' - -puerto = ARGV[ARGV.index('--puerto') + 1].to_i if ARGV.include?('--puerto') -prueba = ServidorPrueba.armar(individuos: %w[gemma-prueba peggy-prueba], puerto: puerto) -pid = ServidorPrueba.arrancar(prueba) -puts "NEXXA de prueba en http://127.0.0.1:#{prueba[:puerto]}/ (pid #{pid}) — usuarios: #{ServidorPrueba::USUARIOS.keys.join(', ')}" -$stdout.flush -trap('INT') { ServidorPrueba.detener(pid, prueba); exit } -trap('TERM') { ServidorPrueba.detener(pid, prueba); exit } -Process.wait(pid) diff --git a/servicios/nexxa/test/ui/01_pools_editar_y_mover.json b/servicios/nexxa/test/ui/01_pools_editar_y_mover.json deleted file mode 100644 index 100f1fb0..00000000 --- a/servicios/nexxa/test/ui/01_pools_editar_y_mover.json +++ /dev/null @@ -1,46 +0,0 @@ -{ - "nombre": "Pools: editar con casillas, guardar y mover entre mente y red", - "acciones": [ - { - "tipo": "click", - "selector": "button[data-section=pools]" - }, - { - "tipo": "esperar_selector", - "selector": ".pool-card" - }, - { - "tipo": "js", - "retorna": true, - "codigo": "document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]').querySelector('[data-action=pool-editar]').click(); return 'editor'" - }, - { - "tipo": "esperar", - "segundos": 0.5 - }, - { - "tipo": "js", - "retorna": true, - "codigo": "var c=document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]'); ['gemini/g-01','gemini/g-02','deepseek/d-01'].forEach(function(v){c.querySelector('input[value=\"'+v+'\"]').checked=true}); c.querySelector('[data-action=pool-guardar]').click(); return 'guardado'" - }, - { - "tipo": "esperar", - "segundos": 1.5 - }, - { - "tipo": "js", - "retorna": true, - "codigo": "document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]').querySelector('.pool-key[data-identificador=d-01] [data-action=pool-mover]').click(); return 'movida'" - }, - { - "tipo": "esperar", - "segundos": 1.5 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^mente: g-01,g-02 \\| red: d-01$", - "codigo": "return Array.from(document.querySelectorAll('.pool-card[data-individuo=gemma-prueba] .pool-col')).map(function(c){return c.dataset.rol+': '+Array.from(c.querySelectorAll('.pool-key')).map(function(k){return k.dataset.identificador}).join(',')}).join(' | ')" - } - ] -} \ No newline at end of file diff --git a/servicios/nexxa/test/ui/02_apis_individuos_y_dashboard.json b/servicios/nexxa/test/ui/02_apis_individuos_y_dashboard.json deleted file mode 100644 index 8ffb8f39..00000000 --- a/servicios/nexxa/test/ui/02_apis_individuos_y_dashboard.json +++ /dev/null @@ -1,47 +0,0 @@ -{ - "nombre": "APIs con chips de pools, alta con pool, Individuos con resumen y Dashboard", - "acciones": [ - { - "tipo": "click", - "selector": "button[data-section=apis]" - }, - { - "tipo": "esperar", - "segundos": 1 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^[1-9]\\d* chips; [1-9]\\d* opciones$", - "codigo": "return document.querySelectorAll('#groups .pool-chip').length + ' chips; ' + document.getElementById('f-pool').options.length + ' opciones'" - }, - { - "tipo": "click", - "selector": "button[data-section=nodos]" - }, - { - "tipo": "esperar", - "segundos": 1 - }, - { - "tipo": "js", - "retorna": true, - "espera": "gemma-prueba: .*Mente 2/2 disponibles.*Red 1/1", - "codigo": "return Array.from(document.querySelectorAll('.consumidor-card[data-individuo]')).map(function(c){return c.dataset.individuo+': '+c.querySelector('.meta').textContent}).join(' || ')" - }, - { - "tipo": "click", - "selector": "button[data-section=dashboard]" - }, - { - "tipo": "esperar", - "segundos": 0.5 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^0$", - "codigo": "return document.getElementById('stat-mente-agotada').textContent" - } - ] -} \ No newline at end of file diff --git a/servicios/nexxa/test/ui/03_renombrar_key.json b/servicios/nexxa/test/ui/03_renombrar_key.json deleted file mode 100644 index a7d00cd3..00000000 --- a/servicios/nexxa/test/ui/03_renombrar_key.json +++ /dev/null @@ -1,36 +0,0 @@ -{ - "nombre": "Renombrar una key desde APIs: el pool la sigue", - "acciones": [ - { - "tipo": "click", - "selector": "button[data-section=apis]" - }, - { - "tipo": "esperar_selector", - "selector": ".key-card[data-identificador=d-01] [data-action=edit]" - }, - { - "tipo": "click", - "selector": ".key-card[data-identificador=d-01] [data-action=edit]" - }, - { - "tipo": "esperar_selector", - "selector": ".ep-identificador" - }, - { - "tipo": "js", - "retorna": true, - "codigo": "document.querySelector('.ep-identificador').value='deepseek-uno'; document.querySelector('[data-action=save-edit]').click(); return 'guardado'" - }, - { - "tipo": "esperar", - "segundos": 1.5 - }, - { - "tipo": "js", - "retorna": true, - "espera": "gemma-prueba · red", - "codigo": "var k=document.querySelector('.key-card[data-identificador=deepseek-uno]'); return k ? Array.from(k.querySelectorAll('.pool-chip')).map(function(c){return c.textContent}).join(',') : 'no aparece'" - } - ] -} \ No newline at end of file diff --git a/servicios/nexxa/test/ui/04_dashboard_y_registro.json b/servicios/nexxa/test/ui/04_dashboard_y_registro.json deleted file mode 100644 index c04f5783..00000000 --- a/servicios/nexxa/test/ui/04_dashboard_y_registro.json +++ /dev/null @@ -1,70 +0,0 @@ -{ - "nombre": "Dashboard con estados AHORA y últimas 24 h, Por key y Registro filtrable (P337/Fase 2), solo lectura", - "produccion": true, - "acciones": [ - { - "tipo": "click", - "selector": "button[data-section=dashboard]" - }, - { - "tipo": "esperar", - "segundos": 2 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^6 estados con [1-9]\\d* keys; [45] contadores 24 h$", - "codigo": "var s=document.querySelectorAll('#stats-ahora .stat'); var n=0; s.forEach(function(x){n+=parseInt(x.querySelector('.stat-value').textContent,10)}); return s.length+' estados con '+n+' keys; '+document.querySelectorAll('#stats-24h .stat').length+' contadores 24 h'" - }, - { - "tipo": "js", - "retorna": true, - "espera": "^por key [1-9]\\d*$", - "codigo": "return 'por key '+document.querySelectorAll('#por-key tbody tr').length" - }, - { - "tipo": "js", - "retorna": true, - "espera": "^textos ok$", - "codigo": "var crudos=Array.prototype.filter.call(document.querySelectorAll('#actividad-lista tbody td:nth-child(3)'),function(x){return /\\s(dispensada|liberada|pausada|renovada|agotada)$/.test(x.textContent)}); return crudos.length?'crudos: '+crudos[0].textContent:'textos ok'" - }, - { - "tipo": "captura", - "destino": "/home/rmonla/Documentos/GitHub/dtic-GEMMA/_temp/p337/ui_dashboard.png" - }, - { - "tipo": "click", - "selector": "[data-ir-registro]" - }, - { - "tipo": "esperar", - "segundos": 2 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^Registro: [1-9]\\d* fila\\(s\\)$", - "codigo": "return document.getElementById('page-title').textContent+': '+document.querySelectorAll('#registro-lista tbody tr').length+' fila(s)'" - }, - { - "tipo": "captura", - "destino": "/home/rmonla/Documentos/GitHub/dtic-GEMMA/_temp/p337/ui_registro.png" - }, - { - "tipo": "js", - "retorna": true, - "espera": "^filtro [a-z-]+$", - "codigo": "var t=document.querySelector('#registro-lista tbody tr td:nth-child(3)').textContent; var sel=document.getElementById('reg-evento'); var o=Array.prototype.find.call(sel.options,function(x){return x.text===t}); sel.value=o.value; sel.dispatchEvent(new Event('change')); return 'filtro '+o.value" - }, - { - "tipo": "esperar", - "segundos": 2 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^filtrado [1-9]\\d* todas iguales$", - "codigo": "var c=Array.prototype.map.call(document.querySelectorAll('#registro-lista tbody tr td:nth-child(3)'),function(x){return x.textContent}); return 'filtrado '+c.length+(c.every(function(x){return x===c[0]})?' todas iguales':' mezcladas')" - } - ] -} \ No newline at end of file diff --git a/servicios/nexxa/test/ui/90_produccion_lectura.json b/servicios/nexxa/test/ui/90_produccion_lectura.json deleted file mode 100644 index 793ca774..00000000 --- a/servicios/nexxa/test/ui/90_produccion_lectura.json +++ /dev/null @@ -1,36 +0,0 @@ -{ - "nombre": "Producción, solo lectura: versión, pools, resumen de individuos y editor (sin guardar)", - "produccion": true, - "acciones": [ - { - "tipo": "esperar", - "segundos": 1.5 - }, - { - "tipo": "js", - "retorna": true, - "espera": "^v\\d+\\.\\d+\\.\\d+$", - "codigo": "return document.getElementById('version-tag').textContent" - }, - { - "tipo": "click", - "selector": "button[data-section=pools]" - }, - { - "tipo": "esperar_selector", - "selector": ".pool-card" - }, - { - "tipo": "js", - "retorna": true, - "espera": "^[1-9]\\d* individuos, [1-9]\\d* keys$", - "codigo": "return document.querySelectorAll('.pool-card').length + ' individuos, ' + document.querySelectorAll('.pool-key').length + ' keys'" - }, - { - "tipo": "js", - "retorna": true, - "espera": "^editor [1-9]", - "codigo": "var c=document.querySelector('.pool-card .pool-col[data-rol=mente]'); c.querySelector('[data-action=pool-editar]').click(); var n=document.querySelectorAll('.pool-editor input').length; document.querySelector('[data-action=pool-cancelar]').click(); return 'editor ' + n" - } - ] -} \ No newline at end of file diff --git a/servicios/nexxa/web/css/estilos.css b/servicios/nexxa/web/css/estilos.css deleted file mode 100644 index 37b9c5d4..00000000 --- a/servicios/nexxa/web/css/estilos.css +++ /dev/null @@ -1,1084 +0,0 @@ - :root { - --bg: #0e1315; - --surface: #161d20; - --surface-raised: #1c2427; - --border: #29343a; - --border-soft: #202a2f; - --text: #e7edee; - --text-dim: #8fa1a3; - --text-faint: #5c6d6f; - --accent: #57c2b7; - --accent-strong: #7fd8cd; - --accent-soft: rgba(87, 194, 183, 0.13); - --accent-border: rgba(87, 194, 183, 0.35); - --ok: #6bc084; - --ok-soft: rgba(107, 192, 132, 0.13); - --warn: #dba94a; - --warn-soft: rgba(219, 169, 74, 0.13); - --danger: #dd6f6a; - --danger-soft: rgba(221, 111, 106, 0.13); - --shadow: 0 20px 44px -20px rgba(0, 0, 0, 0.55); - } - - :root[data-theme="light"] { - --bg: #f2f5f4; - --surface: #ffffff; - --surface-raised: #ffffff; - --border: #d7e0de; - --border-soft: #e4ecea; - --text: #16201f; - --text-dim: #55696a; - --text-faint: #8b9c9c; - --accent: #17847a; - --accent-strong: #106861; - --accent-soft: rgba(23, 132, 122, 0.09); - --accent-border: rgba(23, 132, 122, 0.3); - --ok: #2f8f52; - --ok-soft: rgba(47, 143, 82, 0.1); - --warn: #a5730e; - --warn-soft: rgba(165, 115, 14, 0.1); - --danger: #b7443f; - --danger-soft: rgba(183, 68, 63, 0.09); - --shadow: 0 20px 44px -24px rgba(20, 40, 38, 0.25); - } - - @media (prefers-color-scheme: light) { - :root:not([data-theme="dark"]) { - --bg: #f2f5f4; - --surface: #ffffff; - --surface-raised: #ffffff; - --border: #d7e0de; - --border-soft: #e4ecea; - --text: #16201f; - --text-dim: #55696a; - --text-faint: #8b9c9c; - --accent: #17847a; - --accent-strong: #106861; - --accent-soft: rgba(23, 132, 122, 0.09); - --accent-border: rgba(23, 132, 122, 0.3); - --ok: #2f8f52; - --ok-soft: rgba(47, 143, 82, 0.1); - --warn: #a5730e; - --warn-soft: rgba(165, 115, 14, 0.1); - --danger: #b7443f; - --danger-soft: rgba(183, 68, 63, 0.09); - --shadow: 0 20px 44px -24px rgba(20, 40, 38, 0.25); - } - } - - * { box-sizing: border-box; } - - /* Scrollbar delgado y de la paleta del tema — el default del navegador - desentona con un panel oscuro (Firefox: scrollbar-width/color; Chrome/ - Safari/Edge: pseudo-elementos ::-webkit-scrollbar). Aplicado a cualquier - contenedor con scroll propio (.main-area, .sidebar, listas internas). */ - .main-area, .sidebar, #actividad-lista, #reportes-individuo { - scrollbar-width: thin; - scrollbar-color: var(--border) transparent; - } - - .main-area::-webkit-scrollbar, - .sidebar::-webkit-scrollbar, - #actividad-lista::-webkit-scrollbar, - #reportes-individuo::-webkit-scrollbar { - width: 8px; - } - - .main-area::-webkit-scrollbar-track, - .sidebar::-webkit-scrollbar-track, - #actividad-lista::-webkit-scrollbar-track, - #reportes-individuo::-webkit-scrollbar-track { - background: transparent; - } - - .main-area::-webkit-scrollbar-thumb, - .sidebar::-webkit-scrollbar-thumb, - #actividad-lista::-webkit-scrollbar-thumb, - #reportes-individuo::-webkit-scrollbar-thumb { - background: var(--border); - border-radius: 8px; - } - - .main-area::-webkit-scrollbar-thumb:hover, - .sidebar::-webkit-scrollbar-thumb:hover, - #actividad-lista::-webkit-scrollbar-thumb:hover, - #reportes-individuo::-webkit-scrollbar-thumb:hover { - background: var(--text-faint); - } - - html, body { - height: 100%; - } - - body { - margin: 0; - background: var(--bg); - color: var(--text); - font-family: -apple-system, "Segoe UI", "Helvetica Neue", ui-sans-serif, system-ui, sans-serif; - font-size: 15px; - line-height: 1.5; - -webkit-font-smoothing: antialiased; - } - - .mono { - font-family: ui-monospace, "SF Mono", "Cascadia Code", "JetBrains Mono", Consolas, monospace; - font-variant-numeric: tabular-nums; - } - - a { color: inherit; } - - /* Shell fijo (P204/Fase4, pedido del Operador): antes .app-shell usaba - min-height y toda la página scrolleaba junta — la sidebar terminaba más - alta que la pantalla y se perdía contenido abajo sin forma clara de - saberlo. Ahora la sidebar queda pinneada a 100vh y solo .main-area - scrollea — patrón estándar de "shell fijo + contenido scrolleable". - Sidebar y contenido son paneles FLOTANTES separados del fondo (.app-shell - hace de "fondo", con su propio padding/gap) — no franjas pegadas borde a - borde, patrón de dashboards reales investigado (bento/floating panels). */ - .app-shell { - display: flex; - height: 100vh; - align-items: stretch; - overflow: hidden; - background: var(--bg); - padding: 16px; - gap: 16px; - } - - .sidebar { - width: 208px; - flex-shrink: 0; - background: var(--surface); - border: 1px solid var(--border-soft); - border-radius: 14px; - display: flex; - flex-direction: column; - padding: 20px 12px; - overflow-y: auto; - transition: width 0.16s ease; - } - - .sidebar.collapsed { width: 60px; } - - .sidebar-header { - display: flex; - align-items: center; - justify-content: space-between; - margin-bottom: 26px; - padding: 0 6px; - min-height: 24px; - } - - .sidebar.collapsed .sidebar-header { justify-content: center; } - .sidebar.collapsed .sidebar-header .brand-block { display: none; } - - .sidebar-toggle-btn { - appearance: none; - border: none; - background: transparent; - color: var(--text-dim); - cursor: pointer; - font-size: 15px; - padding: 5px 7px; - border-radius: 7px; - line-height: 1; - } - - .sidebar-toggle-btn:hover { background: var(--bg); color: var(--text); } - - .sidebar-nav { - display: flex; - flex-direction: column; - gap: 3px; - } - - /* Versión visible bajo el brand mark, no al pie (P204/Fase4) — este layout no - tiene sidebar fijo (la página entera scrollea junta, .app-shell usa - min-height, no height), así que "pegado al fondo" vía margin-top:auto - terminaba en el fondo del CONTENIDO total, invisible sin scrollear todo. */ - .version-tag { - font-size: 10.5px; - color: var(--text-faint); - } - - .nav-item { - display: flex; - align-items: center; - gap: 11px; - padding: 10px 11px; - border-radius: 9px; - border: none; - background: transparent; - color: var(--text-dim); - font-size: 13.5px; - font-weight: 600; - cursor: pointer; - text-align: left; - font-family: inherit; - white-space: nowrap; - overflow: hidden; - } - - .nav-item .nav-icon { font-size: 16px; flex-shrink: 0; } - .sidebar.collapsed .nav-item { justify-content: center; padding: 10px; } - .sidebar.collapsed .nav-label { display: none; } - - .nav-item[aria-current="page"] { - background: var(--accent-soft); - color: var(--accent-strong); - } - - .nav-item:not([aria-current="page"]):hover { - background: var(--bg); - color: var(--text); - } - - /* padding-bottom era 80px — sobraba de cuando la página scrolleaba completa - (daba aire al final); con shell fijo eso solo resta espacio real y - provoca overflow innecesario. Sin max-width — el ancho fijo (980px) no - tenía motivo real más que "se veía prolijo" (corregido, Operador): con - más pantalla disponible hay lugar para más paneles por fila sin - scrollear (ver .dash-panels, auto-fit). Sin height explícito — el - align-items:stretch de .app-shell (default de flex) ya le da la altura - correcta, no hace falta duplicarla. */ - .main-area { - flex: 1; - min-width: 0; - padding: 28px 24px; - overflow-y: auto; - } - - .section { display: none; } - .section.active { display: block; } - - .topbar { - display: flex; - align-items: center; - justify-content: space-between; - gap: 16px; - padding-bottom: 22px; - border-bottom: 1px solid var(--border-soft); - margin-bottom: 26px; - } - - .page-title { - font-size: 19px; - font-weight: 700; - margin: 0; - } - - .brand { - display: flex; - align-items: baseline; - gap: 10px; - } - - .brand-mark { - font-size: 19px; - font-weight: 700; - letter-spacing: 0.01em; - } - - .brand-sub { - font-size: 12.5px; - color: var(--text-faint); - font-family: ui-monospace, "SF Mono", Consolas, monospace; - } - - .node-pill { - display: inline-flex; - align-items: center; - gap: 7px; - padding: 6px 12px; - border: 1px solid var(--border); - border-radius: 999px; - font-size: 12.5px; - color: var(--text-dim); - background: var(--surface); - } - - .node-pill .dot { - width: 6px; - height: 6px; - border-radius: 50%; - background: var(--ok); - box-shadow: 0 0 0 3px var(--ok-soft); - } - - .node-pill.error .dot { background: var(--danger); box-shadow: 0 0 0 3px var(--danger-soft); } - - .tabs { - display: inline-flex; - padding: 3px; - border: 1px solid var(--border); - border-radius: 11px; - background: var(--surface); - margin-bottom: 22px; - } - - .tab { - appearance: none; - border: none; - background: transparent; - color: var(--text-dim); - font-size: 13.5px; - font-weight: 600; - padding: 8px 16px; - border-radius: 8px; - cursor: pointer; - font-family: inherit; - transition: background 0.15s ease, color 0.15s ease; - } - - .tab[aria-selected="true"] { - background: var(--accent-soft); - color: var(--accent-strong); - } - - .tab:not([aria-selected="true"]):hover { - color: var(--text); - } - - /* Dashboard (P204/Fase4, rediseñado 2 veces con referencia a patrones - reales de dashboards — barra de métricas full-width primero, después - una grilla de tarjetas PAREJAS). auto-fit + minmax en vez de un número - fijo de columnas (corregido, Operador: "no me gusta lo fijo/rígido") — - el navegador acomoda tantas tarjetas por fila como el ancho disponible - permita, sin depender de breakpoints a mano ni de un max-width fijo en - .main-area. Con las 4 tarjetas actuales, en una pantalla de escritorio - normal entran las 4 en una sola fila; en una más angosta, el mismo grid - las acomoda en 2 filas de 2, sin JS ni media query dedicada. */ - .dash-panels { - display: grid; - grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); - gap: 16px; - } - - .panel-tall { - max-height: 360px; - display: flex; - flex-direction: column; - } - - .panel-tall #actividad-lista, - .panel-tall #por-key { - overflow-y: auto; - flex: 1; - } - - .stats { - display: grid; - grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); - gap: 12px; - margin-bottom: 16px; - } - - .stat { - border: 1px solid var(--border); - background: var(--surface); - border-radius: 12px; - padding: 14px 16px; - } - - .stat-label { - font-size: 11.5px; - text-transform: uppercase; - letter-spacing: 0.06em; - color: var(--text-faint); - margin-bottom: 6px; - } - - .stat-value { - font-size: 22px; - font-weight: 700; - font-family: ui-monospace, "SF Mono", Consolas, monospace; - } - - .stat-value.warn { color: var(--warn); } - .stat-value.info { color: var(--accent); } - - /* P204/Fase4 — gauges, gráfico de barras y actividad reciente del Dashboard */ - .panel { - border: 1px solid var(--border); - background: var(--surface); - border-radius: 12px; - padding: 14px 16px; - } - - .panel-title { - font-size: 11.5px; - text-transform: uppercase; - letter-spacing: 0.06em; - color: var(--text-faint); - margin-bottom: 14px; - } - - .gauge-row { - display: flex; - flex-wrap: wrap; - gap: 24px; - } - - .gauge { - width: 120px; - text-align: center; - } - - .gauge svg { width: 100%; height: auto; } - - .gauge-bg { - fill: none; - stroke: var(--border-soft); - stroke-width: 10; - } - - .gauge-fg { - fill: none; - stroke-width: 10; - stroke-linecap: round; - transition: stroke-dashoffset 0.4s ease; - } - - .gauge-pct { - font-size: 20px; - font-weight: 700; - text-anchor: middle; - fill: var(--text); - font-family: ui-monospace, "SF Mono", Consolas, monospace; - } - - .gauge-sub { - font-size: 10px; - text-anchor: middle; - fill: var(--text-dim); - } - - .gauge-label { - margin-top: 2px; - font-size: 13px; - color: var(--text-dim); - } - - .bar-chart { - display: flex; - align-items: flex-end; - gap: 10px; - height: 76px; - } - - .bar-col { - display: flex; - flex-direction: column; - align-items: center; - justify-content: flex-end; - flex: 1; - } - - .bar { - width: 100%; - max-width: 28px; - background: var(--accent); - border-radius: 3px 3px 0 0; - } - - .bar-label { - font-size: 10px; - color: var(--text-faint); - margin-top: 6px; - } - - .activity-row { - display: flex; - align-items: center; - gap: 10px; - padding: 8px 8px 8px 0; - border-bottom: 1px solid var(--border-soft); - font-size: 13px; - } - - .activity-row:last-child { border-bottom: none; } - - .activity-text { - flex: 1; - color: var(--text-dim); - } - - .activity-text b { color: var(--text); font-weight: 600; } - - .report-row { - display: grid; - grid-template-columns: 100px 1fr 32px; - align-items: center; - gap: 12px; - padding: 7px 0; - } - - .report-label { - font-size: 12.5px; - color: var(--text-dim); - overflow: hidden; - text-overflow: ellipsis; - white-space: nowrap; - } - - .report-bar { - display: flex; - height: 8px; - border-radius: 4px; - overflow: hidden; - background: var(--border-soft); - } - - .report-seg.ok { background: var(--ok); } - .report-seg.warn { background: var(--warn); } - - .report-count { - font-size: 12.5px; - color: var(--text-faint); - text-align: right; - } - - .notice { - display: flex; - gap: 10px; - align-items: flex-start; - border: 1px solid var(--accent-border); - background: var(--accent-soft); - border-radius: 12px; - padding: 12px 14px; - font-size: 13px; - color: var(--text-dim); - margin-bottom: 22px; - } - - .notice.error { - display: none; - border-color: var(--danger); - background: var(--danger-soft); - } - - .notice.error.visible { - display: flex; - } - - .notice strong { color: var(--text); } - - .group-title { - display: flex; - align-items: center; - gap: 8px; - font-size: 12.5px; - text-transform: uppercase; - letter-spacing: 0.06em; - color: var(--text-faint); - margin: 22px 0 10px; - } - - .group-title .line { - flex: 1; - height: 1px; - background: var(--border-soft); - } - - .card-list { - display: flex; - flex-direction: column; - gap: 10px; - } - - .key-card { - border: 1px solid var(--border); - background: var(--surface); - border-radius: 12px; - padding: 14px 16px; - display: grid; - grid-template-columns: 1.2fr 1fr 0.9fr 1.2fr auto; - gap: 14px; - align-items: center; - } - - .card-icon-actions { - display: flex; - gap: 6px; - justify-self: end; - } - - .icon-btn { - width: 30px; - height: 30px; - flex-shrink: 0; - border-radius: 8px; - border: 1px solid var(--border); - background: var(--bg); - color: var(--text-dim); - display: flex; - align-items: center; - justify-content: center; - cursor: pointer; - font-size: 14px; - padding: 0; - } - - .icon-btn:hover { color: var(--text); border-color: var(--text-faint); } - .icon-btn.danger { color: var(--danger); } - .icon-btn.danger:hover { border-color: var(--danger); background: var(--danger-soft); } - .icon-btn.primary { color: var(--accent-strong); border-color: var(--accent-border); } - .icon-btn.primary:hover { background: var(--accent-soft); } - - /* Ficha inline de alta genérica — reusada por APIs (keys) y Nodos - (consumidores, P201/Fase3): un "+" arriba de la lista despliega un - formulario con el mismo estilo visual que las fichas ya cargadas. */ - .add-trigger { - appearance: none; - width: 100%; - display: flex; - align-items: center; - gap: 10px; - border: 1px dashed var(--border); - background: transparent; - color: var(--text-dim); - font-size: 13.5px; - font-weight: 600; - font-family: inherit; - padding: 12px 16px; - border-radius: 12px; - cursor: pointer; - margin-bottom: 14px; - } - - .add-trigger:hover { - border-color: var(--accent-border); - color: var(--accent-strong); - background: var(--accent-soft); - } - - .add-plus { - font-size: 16px; - line-height: 1; - } - - /* Especificidad "div.inline-add-form" a propósito: gana el empate con - .key-card/.consumidor-card (misma especificidad de clase única) sin - depender del orden de aparición en la hoja de estilos. */ - div.inline-add-form { - display: none; - flex-direction: column; - gap: 12px; - margin-bottom: 14px; - border-color: var(--accent-border); - } - - div.inline-add-form.visible { display: flex; } - - .inline-add-row { - display: grid; - grid-template-columns: 1fr 1fr 1fr 1fr auto; - gap: 12px; - align-items: end; - } - - .inline-add-field label { - display: block; - font-size: 10.5px; - text-transform: uppercase; - letter-spacing: 0.06em; - color: var(--text-faint); - margin-bottom: 5px; - } - - .inline-add-field input, .inline-add-field select { - width: 100%; - padding: 8px 10px; - border-radius: 8px; - border: 1px solid var(--border); - background: var(--bg); - color: var(--text); - font-size: 13.5px; - font-family: inherit; - } - - .inline-add-field.secret-field { position: relative; } - .inline-add-field.secret-field input { padding-right: 62px; } - - .inline-add-field .secret-toggle { - position: absolute; - right: 6px; - top: 28px; - background: none; - border: none; - color: var(--text-faint); - font-size: 11.5px; - cursor: pointer; - padding: 4px 6px; - } - - .inline-add-field.has-error input { border-color: var(--danger); } - - .inline-add-hint { - font-size: 11.5px; - color: var(--text-faint); - margin: 0; - } - - @media (max-width: 640px) { - .inline-add-row { grid-template-columns: 1fr 1fr; } - } - - .key-card.is-new { - animation: pop 1.2s ease; - border-color: var(--accent-border); - } - - @keyframes pop { - 0% { background: var(--accent-soft); } - 100% { background: var(--surface); } - } - - .field-label { - font-size: 10.5px; - text-transform: uppercase; - letter-spacing: 0.06em; - color: var(--text-faint); - margin-bottom: 3px; - } - - .id-block .id { - font-weight: 600; - font-size: 14.5px; - } - - .id-block .provider { - color: var(--text-dim); - font-size: 12.5px; - } - - .owner { - font-size: 13.5px; - color: var(--text); - font-weight: 600; - } - - .owner.unassigned { - color: var(--text-faint); - font-weight: 400; - font-style: italic; - } - - .pill { - display: inline-flex; - align-items: center; - gap: 6px; - padding: 4px 10px; - border-radius: 999px; - font-size: 12px; - font-weight: 600; - width: fit-content; - } - - .pill .dot { width: 6px; height: 6px; border-radius: 50%; } - - .pill.ok { background: var(--ok-soft); color: var(--ok); } - .pill.ok .dot { background: var(--ok); } - - .pill.warn { background: var(--warn-soft); color: var(--warn); } - .pill.warn .dot { background: var(--warn); } - - .pill.info { background: var(--accent-soft); color: var(--accent); } - .pill.info .dot { background: var(--accent); } - /* P337/Fase 2: en pausa (límite del proveedor, vuelve en minutos) se distingue de agotada (cuota) */ - .pill.pause { background: var(--warn-soft); color: var(--text); border: 1px dashed var(--warn); } - .pill.pause .dot { background: var(--warn); opacity: 0.6; } - - .timing { - font-size: 12.5px; - color: var(--text-dim); - } - - .timing .value { color: var(--text); } - - .timing-sub { - font-size: 11.5px; - color: var(--text-faint); - margin-top: 3px; - } - - .key-actions { - grid-column: 1 / -1; - display: flex; - gap: 8px; - padding-top: 12px; - margin-top: 2px; - border-top: 1px solid var(--border-soft); - } - - .action-btn { - appearance: none; - border: 1px solid var(--border); - background: var(--bg); - color: var(--text-dim); - font-size: 12px; - font-weight: 600; - padding: 5px 11px; - border-radius: 7px; - cursor: pointer; - font-family: inherit; - } - - .action-btn:hover { color: var(--text); border-color: var(--text-faint); } - .action-btn.danger { color: var(--danger); } - .action-btn.danger:hover { border-color: var(--danger); background: var(--danger-soft); } - .action-btn.confirm { color: #08211e; background: var(--danger); border-color: var(--danger); } - .action-btn.primary { color: var(--accent-strong); border-color: var(--accent-border); } - - .edit-panel { - grid-column: 1 / -1; - display: flex; - gap: 10px; - align-items: flex-end; - padding-top: 12px; - margin-top: 2px; - border-top: 1px solid var(--border-soft); - flex-wrap: wrap; - } - - .edit-panel .ep-field { display: flex; flex-direction: column; gap: 4px; } - .edit-panel label { font-size: 10.5px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--text-faint); } - .edit-panel input, .edit-panel select { - padding: 6px 9px; - border-radius: 7px; - border: 1px solid var(--border); - background: var(--bg); - color: var(--text); - font-size: 13px; - font-family: inherit; - } - - .pill.inactive { background: var(--border-soft); color: var(--text-faint); } - .pill.inactive .dot { background: var(--text-faint); } - - .empty-state { - border: 1px dashed var(--border); - border-radius: 12px; - padding: 34px 18px; - text-align: center; - color: var(--text-faint); - font-size: 13.5px; - } - - .token-banner .token-value { - display: inline-block; - background: var(--bg); - border: 1px solid var(--border); - border-radius: 7px; - padding: 6px 10px; - margin: 6px 8px 6px 0; - font-size: 13px; - word-break: break-all; - } - - .consumidor-card { - border: 1px solid var(--border); - background: var(--surface); - border-radius: 12px; - padding: 14px 16px; - display: flex; - align-items: center; - justify-content: space-between; - gap: 14px; - margin-bottom: 10px; - flex-wrap: wrap; - } - - .consumidor-info .id { font-weight: 600; font-size: 14.5px; } - .consumidor-info .meta { color: var(--text-dim); font-size: 12.5px; margin-top: 2px; } - - /* Check-in proactivo (P216/Fase4) — badge de estado real, segunda línea de la card */ - .badge { - display: inline-block; - margin-top: 4px; - padding: 2px 8px; - border-radius: 6px; - font-size: 11.5px; - font-weight: 600; - background: var(--border-soft); - color: var(--text-faint); - } - .badge.success { background: var(--ok-soft); color: var(--ok); } - .badge.warning { background: var(--warn-soft); color: var(--warn); } - .badge.stale { background: var(--danger-soft); color: var(--danger); } - - .secret-toggle { - position: absolute; - right: 8px; - top: 32px; - background: none; - border: none; - color: var(--text-faint); - font-size: 12px; - cursor: pointer; - padding: 4px 6px; - } - - .secret-toggle:hover { color: var(--text-dim); } - - .hint-conditional { - display: none; - color: var(--danger); - } - - .hint-conditional.visible { - display: block; - } - - .confirm-banner, .error-banner { - display: none; - align-items: flex-start; - gap: 10px; - border-radius: 12px; - padding: 14px 16px; - margin-bottom: 18px; - font-size: 13.5px; - } - - .confirm-banner { - border: 1px solid var(--ok); - background: var(--ok-soft); - } - - .error-banner { - border: 1px solid var(--danger); - background: var(--danger-soft); - } - - .confirm-banner.visible, .error-banner.visible { display: flex; } - - .confirm-banner .title { font-weight: 700; color: var(--ok); display: block; margin-bottom: 3px; } - .error-banner .title { font-weight: 700; color: var(--danger); display: block; margin-bottom: 3px; } - .confirm-banner .body, .error-banner .body { color: var(--text-dim); } - - .view { display: none; } - .view.active { display: block; } - - @media (max-width: 640px) { - .key-card { grid-template-columns: 1fr 1fr; row-gap: 10px; } - .panel-tall { max-height: none; } - } - - @media (prefers-reduced-motion: reduce) { - .key-card.is-new { animation: none; } - } - - .modal-backdrop { - display: none; - position: fixed; - inset: 0; - background: rgba(4, 8, 9, 0.6); - align-items: center; - justify-content: center; - z-index: 100; - padding: 20px; - } - - .modal-backdrop.visible { display: flex; } - - .modal { - background: var(--surface-raised); - border: 1px solid var(--border); - border-radius: 14px; - padding: 26px; - max-width: 360px; - width: 100%; - box-shadow: var(--shadow); - text-align: center; - } - - .modal-icon { font-size: 30px; margin-bottom: 10px; } - .modal h3 { margin: 0 0 8px; font-size: 16px; } - .modal-body { color: var(--text-dim); font-size: 13.5px; margin: 0 0 18px; line-height: 1.5; } - .modal-body b { color: var(--text); } - - .modal-field { text-align: left; margin-bottom: 18px; } - .modal-field label { - display: block; - font-size: 11.5px; - color: var(--text-faint); - margin-bottom: 6px; - } - .modal-field input { - width: 100%; - padding: 9px 11px; - border-radius: 8px; - border: 1px solid var(--border); - background: var(--bg); - color: var(--text); - font-size: 14px; - } - .modal-field input:focus { - outline: none; - border-color: var(--danger); - box-shadow: 0 0 0 3px var(--danger-soft); - } - - .modal-actions { display: flex; gap: 10px; justify-content: center; } - .modal-actions .action-btn { padding: 8px 16px; font-size: 13px; } - .modal-actions .action-btn.confirm:disabled { - opacity: 0.4; - cursor: not-allowed; - background: var(--border); - border-color: var(--border); - color: var(--text-faint); - } - - /* Pools por individuo: mente y red (P335/Fase 7) */ - #pools-lista { display: flex; flex-direction: column; gap: 10px; } - .key-card.pool-card { grid-template-columns: 0.8fr 1.6fr 1.6fr; align-items: start; } - .pool-col { display: flex; flex-direction: column; gap: 8px; min-width: 0; } - .pool-key { - display: grid; - grid-template-columns: 1fr auto auto; - gap: 8px; - align-items: center; - padding: 6px 8px; - border: 1px solid var(--border); - border-radius: 8px; - } - @media (max-width: 640px) { - .key-card.pool-card { grid-template-columns: 1fr; } - } - - /* Editor de pools (P335/Fase 12) */ - .pool-col-titulo { display: flex; align-items: center; justify-content: space-between; gap: 8px; } - .pool-key .card-icon-actions { justify-self: end; } - .pool-editor { display: flex; flex-direction: column; gap: 8px; padding: 8px; border: 1px dashed var(--border); border-radius: 8px; } - .pool-editor-grupo { display: flex; flex-direction: column; gap: 4px; } - .pool-editor-item { display: flex; align-items: center; gap: 6px; cursor: pointer; } - .pool-editor-acciones { display: flex; gap: 6px; } - .pools-chips { display: flex; flex-wrap: wrap; gap: 4px; margin-top: 4px; } - .pool-chip { font-size: 11px; padding: 1px 6px; border-radius: 999px; background: var(--accent-soft); color: var(--accent); } - .pool-chip.red { background: var(--warn-soft); color: var(--warn); } - - /* Alta de key: un campo más ("Asignar a pool", P335/Fase 12) solo en esta fila */ - #add-key-form > .inline-add-row:first-child { grid-template-columns: 1fr 1fr 1fr 1fr 1fr auto; } - @media (max-width: 640px) { - #add-key-form > .inline-add-row:first-child { grid-template-columns: 1fr 1fr; } - } - -/* P337/Fase 2: registro y dashboard concretos */ -.stats-titulo { font-weight: 600; margin: 4px 0 6px; } -.stats-titulo .stats-sub { font-weight: 400; color: var(--text-faint); font-size: 0.85em; margin-left: 6px; } -.tabla-registro { width: 100%; border-collapse: collapse; font-size: 0.9em; } -.tabla-registro th { text-align: left; color: var(--text-faint); font-weight: 500; padding: 6px 8px; border-bottom: 1px solid var(--border-soft); } -.tabla-registro td { padding: 6px 8px; border-bottom: 1px solid var(--border-soft); vertical-align: top; } -.tabla-registro .nowrap { white-space: nowrap; } -.registro-filtros { display: flex; flex-wrap: wrap; gap: 12px; align-items: end; margin-bottom: 12px; } -.registro-filtros label { display: flex; flex-direction: column; gap: 4px; font-size: 0.85em; color: var(--text-faint); } -.registro-cuenta { margin-left: auto; color: var(--text-faint); } -.panel-link { float: right; font-size: 0.85em; font-weight: 400; } -#section-registro { overflow-x: auto; } -/* Las tablas del dashboard ocupan el ancho completo (en un panel angosto se desbordaban) y las 6 cajas de estado - entran en una fila en pantallas comunes */ -.dash-panels .panel-tall { grid-column: 1 / -1; } -.panel-tall #actividad-lista, .panel-tall #por-key { overflow-x: auto; } -#stats-ahora { grid-template-columns: repeat(auto-fit, minmax(120px, 1fr)); } -#stats-ahora .stat-label .pill { font-size: 10.5px; } - diff --git a/servicios/nexxa/web/index.html b/servicios/nexxa/web/index.html deleted file mode 100644 index b8cdec05..00000000 --- a/servicios/nexxa/web/index.html +++ /dev/null @@ -1,310 +0,0 @@ - - - - - -NEXXA · Panel de administración - - - -

- - -
-
-

Dashboard

-
- -
conectando…
- -
-
- -
- -
Ahora estado de cada key
-
-
Últimas 24 h qué pasó con las keys
-
-
-
-
Keys registradas
-
—
-
-
-
Providers
-
—
-
-
-
Consumidores
-
—
-
-
-
Mentes sin keys
-
—
-
-
- -
-
-
Distribución de APIs por proveedor
-
-
- -
-
Entregas por día (últimos 7 días)
-
-
- -
-
Por key (últimas 24 h)
-
-
- -
-
Últimos eventos ver registro completo →
-
-
-
-
- -
-
- 🔒 - Solo metadata. Esta vista nunca muestra el valor de una key — ni completo, ni parcial. El valor real solo se entrega a un individuo autenticado vía GET /disponible/<provider|mente|red>. -
- -
- -
- ⚠️ - - No se pudo registrar la key - - -
- - - -
-
-
- - - -
-
- - - Obligatorio. - Ya existe. -
-
- - - - Obligatorio. -
-
- - -
-
- - -
-
- - -
-
- -
-
- - - - Obligatorio. -
-
- -

🛈 Se cifra al llegar a NEXXA — no se vuelve a mostrar en pantalla una vez cargada, ni en esta mini-app ni en apids chat.

-

🛈 La estimación de reset es solo un respaldo — se usa cuando un consumidor reporta "agotada" sin informar un tiempo real del proveedor. Desde P204/Fase3, dispensar la key ya NO la bloquea automáticamente: el consumidor es quien reporta salud real.

-
- -
-
- - -
-
- - - - - -
-
-
- -
-
- 🧩 - Pools por individuo (P335). Cada individuo piensa y opera con las keys de su pool Mente y usa las de su pool Red solo para avisar que se quedó sin batería. Un pool puede mezclar proveedores y una key puede estar en varios pools. El individuo las pide con GET /disponible/mente o /disponible/red; con un pool vacío NEXXA responde pool_vacio, nunca cae a otra key. -
-
-
-
- -
-
- 🔑 - Individuos con acceso. Cada uno tiene un token propio para pedir keys vía GET /disponible/<provider|mente|red>. El token se muestra en claro una única vez, al generarlo — nunca se vuelve a mostrar después. -
- -
- 📡 - Check-in proactivo (P216). Cada individuo reporta su propio estado — nunca deducido. El badge de abajo de cada tarjeta refleja el último reporte real, o "sin check-in" si el individuo todavía no adoptó el mecanismo. -
- -
- 🔑 - - - - - - - Guardalo ahora (ej. en candados) — no se vuelve a mostrar en esta pantalla. - -
- -
- ⚠️ - - No se pudo completar la operación - - -
- - - -
-
-
- - - Obligatorio. -
-
- - -
-
-

🛈 Si el individuo ya tenía token, esto lo reemplaza (rotación) — el viejo deja de servir.

-
- -
-
- -
-
- 👤 - Gestión de usuarios. Solo perfil admin puede crear, editar o eliminar usuarios del panel. El último admin activo no se puede degradar ni eliminar. -
- -
- ⚠️ - - No se pudo completar la operación - - -
- - - -
-
-
- - - Obligatorio. -
-
- - -
-
- - - - Obligatorio. -
-
- - -
-
-

🛈 El usuario nuevo cambia su password desde acá mismo (editar) cuando quiera — no hay auto-reset.

-
- -
-
-
-
- - - - - - diff --git a/servicios/nexxa/web/js/app.js b/servicios/nexxa/web/js/app.js deleted file mode 100644 index f9c57f39..00000000 --- a/servicios/nexxa/web/js/app.js +++ /dev/null @@ -1,1468 +0,0 @@ - (function () { - "use strict"; - - // Sesión: cualquier 401 (cookie vencida/inválida) recarga la página — - // server.rb decide server-side si corresponde servir login.html o - // index.html, sin lógica de auth duplicada acá (P201/Fase4). - var _fetch = window.fetch; - window.fetch = function (url, opts) { - return _fetch(url, opts).then(function (r) { - if (r.status === 401) location.reload(); - return r; - }); - }; - - document.getElementById("logout-btn").addEventListener("click", function () { - fetch("/logout", { method: "POST" }).finally(function () { location.reload(); }); - }); - - var HOUR = 3600 * 1000; - var keys = []; - var lastCreated = null; - var editing = null; - var pendingDelete = null; - var RESET_OPTIONS = [ - { value: 86400, label: "24 horas" }, - { value: 3600, label: "1 hora" }, - { value: 604800, label: "7 días" } - ]; - - var nodePill = document.getElementById("node-pill"); - var nodePillText = document.getElementById("node-pill-text"); - var loadError = document.getElementById("load-error"); - - // Navegación de la barra lateral (Dashboard / APIs / Nodos, P201/Fase3) - var sidebar = document.getElementById("sidebar"); - var sidebarToggle = document.getElementById("sidebar-toggle"); - var navItems = document.querySelectorAll(".nav-item"); - var pageTitle = document.getElementById("page-title"); - var sectionTitles = { dashboard: "Dashboard", apis: "APIs", nodos: "Individuos", pools: "Pools", registro: "Registro", usuarios: "Usuarios" }; - - function selectSection(which) { - navItems.forEach(function (item) { - var activo = item.getAttribute("data-section") === which; - if (activo) { - item.setAttribute("aria-current", "page"); - } else { - item.removeAttribute("aria-current"); - } - }); - document.getElementById("section-dashboard").classList.toggle("active", which === "dashboard"); - document.getElementById("section-apis").classList.toggle("active", which === "apis"); - document.getElementById("section-nodos").classList.toggle("active", which === "nodos"); - document.getElementById("section-pools").classList.toggle("active", which === "pools"); - document.getElementById("section-registro").classList.toggle("active", which === "registro"); - document.getElementById("section-usuarios").classList.toggle("active", which === "usuarios"); - pageTitle.textContent = sectionTitles[which]; - - if (which === "nodos") { - tokenBanner.classList.remove('visible'); - consumidoresErrorBanner.classList.remove('visible'); - cargarCheckins().then(cargarConsumidores); - } else if (which === "pools") { - cargarPools(); - } else if (which === "registro") { - cargarRegistro(); - } else if (which === "usuarios") { - usuariosErrorBanner.classList.remove('visible'); - cargarUsuarios(); - } - } - - navItems.forEach(function (item) { - item.addEventListener("click", function () { selectSection(item.getAttribute("data-section")); }); - }); - - sidebarToggle.addEventListener("click", function () { - sidebar.classList.toggle("collapsed"); - }); - - // Sesión actual (P201/Fase4) — gatea "Usuarios" y todo el CRUD de - // keys/consumidores por perfil: 'operador' es solo-lectura (corrección - // 2026-08-03 — el diseño original lo dejaba mutar, error). esAdmin se - // resuelve ANTES del primer cargarKeys()/cargarConsumidores() para que - // los botones de escritura no aparezcan ni un instante y se oculten - // después (Advertir antes que fallar — no mostrar controles que el - // backend va a rechazar). - var esAdmin = false; - var sesionActualEl = document.getElementById("sesion-actual"); - var navUsuarios = document.getElementById("nav-usuarios"); - fetch("/session") - .then(function (r) { return r.ok ? r.json() : null; }) - .then(function (s) { - if (s) { - esAdmin = s.perfil === "admin"; - sesionActualEl.textContent = s.usuario + " · " + s.perfil; - if (esAdmin) navUsuarios.style.display = ""; - if (!esAdmin) { - document.getElementById("add-key-trigger").style.display = "none"; - document.getElementById("add-consumidor-trigger").style.display = "none"; - } - } - }) - .catch(function () {}) - .finally(function () { - cargarKeys(); - setInterval(cargarKeys, 30000); - cargarCheckins().then(cargarConsumidores); - setInterval(cargarConsumidores, 30000); // resumen de pools y 'Mentes sin keys' al día (P335/Fase 12) - cargarUsos(); - setInterval(cargarUsos, 30000); - cargarResumen(); - setInterval(cargarResumen, 30000); - cargarVersion(); - }); - - // P204/Fase4 — build stamp visible (pedido del Operador, tras confusión - // real por caché del navegador): confirma que lo que se está viendo - // corresponde al último deploy, sin adivinar por el contenido. - function cargarVersion() { - var el = document.getElementById("version-tag"); - if (!el) return; - fetch('/version') - .then(function (r) { return r.json(); }) - .then(function (d) { el.textContent = 'v' + d.version; }) - .catch(function () {}); - } - - function fmtRelative(iso) { - var ts = new Date(iso).getTime(); - var diff = ts - Date.now(); - var abs = Math.abs(diff); - var h = abs / HOUR; - var text; - if (h < 1) { - text = Math.round(abs / 60000) + "m"; - } else if (h < 48) { - text = h.toFixed(1) + "h"; - } else { - text = Math.round(h / 24) + "d"; - } - return diff <= 0 ? "hace " + text : "en " + text; - } - - // Texto que viene de afuera (motivo que manda un consumidor, nombres) nunca entra crudo al HTML (P335/Fase 7) - function esc(t) { - return String(t == null ? '' : t).replace(/[&<>"']/g, function (c) { - return { '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]; - }); - } - - // Chips "individuo · rol" de los pools de una key (P335/Fase 12): fuente única para APIs e Individuos - function chipsPools(pools) { - if (!pools || !pools.length) return ''; - return '
' + pools.map(function (p) { - return '' + esc(p.individuo) + ' · ' + esc(p.rol) + ''; - }).join('') + '
'; - } - - function fmtClock(iso) { - var d = new Date(iso); - return d.toLocaleString("es-AR", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" }); - } - - // P337/Fase 2: el ESTADO viene del servidor (taxonomía única, Registro.estado_de); acá solo se muestra en palabras, - // con hora absoluta y relativa. Nunca se recalcula en el navegador. - var ESTADO_UI = { - disponible: { clase: 'ok', texto: 'disponible' }, - en_uso: { clase: 'info', texto: 'en uso' }, - en_pausa: { clase: 'pause', texto: 'en pausa' }, - agotada: { clase: 'warn', texto: 'agotada' }, - desactivada: { clase: 'inactive', texto: 'desactivada' }, - sin_valor: { clase: 'inactive', texto: 'sin valor' } - }; - var ESTADOS_ORDEN = ['disponible', 'en_uso', 'en_pausa', 'agotada', 'desactivada', 'sin_valor']; - - function cuando(iso) { - return iso ? fmtClock(iso) + ' (' + fmtRelative(iso) + ')' : ''; - } - - function detalleEstado(f) { - switch (f.estado) { - case 'en_uso': return 'por ' + esc(f.por || '?') + ' · hasta ' + cuando(f.hasta); - case 'en_pausa': return 'límite del proveedor · vuelve ' + cuando(f.hasta) + (f.motivo ? ' · ' + esc(f.motivo) : ''); - case 'agotada': return 'cuota agotada · vuelve ' + cuando(f.hasta) + (f.por ? ' · reportó ' + esc(f.por) : '') + - (f.motivo ? ' · ' + esc(f.motivo) : ''); - case 'sin_valor': return 'cargada sin la clave: no se puede entregar'; - default: return ''; - } - } - - function estadoHtml(f) { - var e = ESTADO_UI[f.estado] || { clase: 'inactive', texto: f.estado || '?' }; - var d = detalleEstado(f); - return '' + e.texto + '' + - (d ? '
' + d + '
' : ''); - } - - // Eventos del registro (P337/Fase 3): el TEXTO lo manda el servidor (Usos::TEXTOS, fuente única con GEMMA, llega en - // /resumen); acá solo el ícono, que es presentación. - var EVENTO_ICONO = { - dispensada: '🟢', liberada: '⚪', renovada: '🔄', pausada: '🟡', agotada: '🔴', revertida: '↩️', - 'liberada-admin': '🛠', alta: '➕', editada: '✏️', renombrada: '🏷', baja: '🗑', 'agotada-previa': '🟠' - }; - var TEXTOS_EVENTO = {}; - - // texto: el que manda el servidor en cada fila de /usos (no depende de que /resumen haya llegado antes) - function eventoTexto(e, texto) { - return (EVENTO_ICONO[e] || '•') + ' ' + (texto || TEXTOS_EVENTO[e] || e); - } - - function actionsHtml(k, keyId, activo, bloqueada) { - if (!esAdmin) return ''; - return '
' + - (bloqueada ? '' : '') + - '' + - '' + - '' + - '
'; - } - - function editPanelHtml(k) { - var options = RESET_OPTIONS.map(function (o) { - return ''; - }).join(''); - - // Identificador editable (P335/Fase 13): NEXXA actualiza también los pools que la usan - var avisoPools = k.pools && k.pools.length ? ' title="También se actualiza en ' + k.pools.length + ' pool(s)"' : ''; - return '
' + - '
' + - '' + - '' + - '
' + - '
' + - '' + - '' + - '
' + - '
' + - '' + - '' + - '
' + - '' + - '' + - '
'; - } - - function patchKey(provider, identificador, body) { - return fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador), { - method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(body) - }).then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }); - } - - function deleteKey(provider, identificador) { - return fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador), { method: 'DELETE' }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }); - } - - function mostrarErrorAccion(msg) { - loadError.textContent = msg; - loadError.classList.add('visible'); - } - - // ---------- Consumidores (individuos con token, P201/Fase3) ---------- - - var consumidores = []; - var consumidoresErrorBanner = document.getElementById("consumidores-error-banner"); - var consumidoresErrorTitle = document.getElementById("consumidores-error-title"); - var tokenBanner = document.getElementById("token-banner"); - var tokenBannerTitle = document.getElementById("token-banner-title"); - var tokenBannerValue = document.getElementById("token-banner-value"); - var tokenCopyBtn = document.getElementById("token-copy-btn"); - - function mostrarErrorConsumidores(msg) { - consumidoresErrorTitle.textContent = msg; - consumidoresErrorBanner.classList.add('visible'); - } - - // ---------- Check-in proactivo (P216/Fase4) ---------- - // Ventana de "reciente" — mismo criterio que bandeja.rb (4x una cadencia - // típica de latido ~300s). Best-effort: si /checkins falla, el resto del - // panel sigue funcionando, solo sin badges. - var checkins = {}; - var CHECKIN_VENTANA_MS = 20 * 60 * 1000; - - function cargarCheckins() { - return fetch('/checkins') - .then(function (r) { return r.ok ? r.json() : {}; }) - .then(function (data) { checkins = data || {}; }) - .catch(function () { checkins = {}; }); - } - - function checkinBadgeHtml(individuo) { - var c = checkins[individuo]; - if (!c || !c.ultimo_reporte) { - return 'sin check-in'; - } - var edad = Date.now() - new Date(c.ultimo_reporte).getTime(); - var reciente = edad <= CHECKIN_VENTANA_MS; - var clase = reciente && c.estado === 'ok' ? 'badge success' : reciente ? 'badge warning' : 'badge stale'; - var etiqueta = reciente ? c.estado : 'stale'; - var texto = etiqueta + ' · ' + fmtRelative(c.ultimo_reporte) + (c.detalle ? ' · ' + c.detalle : ''); - return '' + texto + ''; - } - - function cargarConsumidores() { - return fetch('/consumidores') - .then(function (r) { - if (!r.ok) throw new Error('HTTP ' + r.status); - return r.json(); - }) - .then(function (data) { - consumidores = data; - renderConsumidores(); - }) - .catch(function (e) { - mostrarErrorConsumidores('No se pudo cargar la lista (' + e.message + ').'); - }); - } - - function renderConsumidores() { - document.getElementById("stat-consumidores").textContent = consumidores.length; - // Mente con keys asignadas pero ninguna disponible: NEXXA ya le informa 'agotado' y el individuo decide (red) - var sinMente = consumidores.filter(function (c) { var m = (c.pools || {}).mente; return m && m.total > 0 && m.disponibles === 0; }); - var statMente = document.getElementById("stat-mente-agotada"); - statMente.textContent = sinMente.length; - statMente.title = sinMente.map(function (c) { return c.individuo; }).join(', '); - - actualizarOpcionesPoolAlta(); - var list = document.getElementById("consumidores-list"); - if (!consumidores.length) { - list.innerHTML = '
Sin individuos con token todavía. Generá el primero abajo.
'; - return; - } - - list.innerHTML = consumidores.map(function (c) { - return '
' + - '
' + - '
' + esc(c.individuo) + '
' + - '
' + resumenPoolsHtml(c.pools) + '
' + - '
token creado ' + fmtRelative(c.creado) + ' · ' + fmtClock(c.creado) + '
' + - '
' + checkinBadgeHtml(c.individuo) + '
' + - '
' + - (esAdmin - ? '
' + - '' + - '' + - '' + - '
' - : '') + - '
'; - }).join(''); - } - - // "🧠 Mente 3/4 · 🪫 Red 1/1" (disponibles/total) — P335/Fase 12 - function resumenPoolsHtml(pools) { - if (!pools) return ''; - return [['mente', '🧠 Mente'], ['red', '🪫 Red']].map(function (r) { - var p = pools[r[0]] || { total: 0, disponibles: 0 }; - if (!p.total) return r[1] + ' vacío'; - var clase = p.disponibles === 0 ? ' class="warn"' : ''; - return r[1] + ' ' + p.disponibles + '/' + p.total + ' disponibles'; - }).join(' · '); - } - - // Alta de key: asignarla a un pool en el mismo paso (opcional, P335/Fase 12) - function actualizarOpcionesPoolAlta() { - var sel = document.getElementById("f-pool"); - var actual = sel.value; - sel.innerHTML = '' + consumidores.map(function (c) { - return ['mente', 'red'].map(function (rol) { - var v = esc(c.individuo) + '/' + rol; - return ''; - }).join(''); - }).join(''); - sel.value = actual; - } - - function generarToken(individuo) { - return fetch('/consumidores', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ individuo: individuo }) - }).then(function (r) { - return r.json().then(function (data) { - if (!r.ok) throw new Error(data.error || ('HTTP ' + r.status)); - return data; - }); - }); - } - - function mostrarTokenGenerado(individuo, token) { - tokenBannerTitle.textContent = 'Token generado para ' + individuo + '.'; - tokenBannerValue.textContent = token; - tokenBanner.classList.add('visible'); - } - - tokenCopyBtn.addEventListener("click", function () { - navigator.clipboard.writeText(tokenBannerValue.textContent).then(function () { - tokenCopyBtn.textContent = "Copiado"; - setTimeout(function () { tokenCopyBtn.textContent = "Copiar"; }, 1500); - }); - }); - - var nuevoIndividuoInput = document.getElementById("f-nuevo-individuo"); - - var addConsumidorToggler = crearTogglerInline("add-consumidor-trigger", "add-consumidor-form", "f-nuevo-individuo", function () { - nuevoIndividuoInput.value = ""; - marcarCampoRequerido("field-nuevo-individuo", "hint-individuo-required", false); - }); - - document.getElementById("add-consumidor-trigger").addEventListener("click", addConsumidorToggler.abrir); - - document.getElementById("add-consumidor-form").addEventListener("click", function (e) { - var btn = e.target.closest("[data-action]"); - if (!btn) return; - if (btn.getAttribute("data-action") === "cancel-new-consumidor") addConsumidorToggler.cerrar(); - if (btn.getAttribute("data-action") === "save-new-consumidor") guardarConsumidorNuevo(btn); - }); - - function guardarConsumidorNuevo(btn) { - var individuo = nuevoIndividuoInput.value.trim(); - var vacio = !individuo; - marcarCampoRequerido("field-nuevo-individuo", "hint-individuo-required", vacio); - if (vacio) return; - - btn.disabled = true; - - generarToken(individuo) - .then(function (data) { - addConsumidorToggler.cerrar(); - mostrarTokenGenerado(data.individuo, data.token); - return cargarConsumidores(); - }) - .catch(function (err) { mostrarErrorConsumidores('No se pudo generar el token: ' + err.message); }) - .finally(function () { btn.disabled = false; }); - } - - document.getElementById("consumidores-list").addEventListener("click", function (e) { - var btn = e.target.closest("[data-consumidor-action]"); - if (!btn) return; - var card = e.target.closest(".consumidor-card"); - var individuo = card.getAttribute("data-individuo"); - var action = btn.getAttribute("data-consumidor-action"); - - if (action === "rotar") { - generarToken(individuo) - .then(function (data) { - mostrarTokenGenerado(data.individuo, data.token); - return cargarConsumidores(); - }) - .catch(function (err) { mostrarErrorConsumidores('No se pudo rotar el token: ' + err.message); }); - } else if (action === "pools") { - selectSection("pools"); - } else if (action === "revocar") { - abrirModalConfirmacion({ - titulo: "Revocar acceso", - confirmValue: individuo, - accion: "Sí, revocar", - accionEnCurso: "Revocando…", - bodyHtml: '¿Revocar el acceso de ' + esc(individuo) + '? Esta acción no se puede deshacer — el individuo no va a poder pedir keys hasta que se le genere un token nuevo.' + - '

⚠️ También se borran sus pools Mente y Red (sin token no los puede usar).', - onConfirm: function () { - return fetch('/consumidores/' + encodeURIComponent(individuo), { method: 'DELETE' }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }); - }, - onDone: cargarConsumidores - }); - } - }); - - // ---------- Usuarios (gestión del panel, P201/Fase4 — solo perfil admin) ---------- - - var usuarios = []; - var editingUsuario = null; - var usuariosErrorBanner = document.getElementById("usuarios-error-banner"); - var usuariosErrorTitle = document.getElementById("usuarios-error-title"); - - function mostrarErrorUsuarios(msg) { - usuariosErrorTitle.textContent = msg; - usuariosErrorBanner.classList.add('visible'); - } - - function cargarUsuarios() { - return fetch('/usuarios') - .then(function (r) { - if (!r.ok) throw new Error('HTTP ' + r.status); - return r.json(); - }) - .then(function (data) { - usuarios = data; - renderUsuarios(); - }) - .catch(function (e) { - mostrarErrorUsuarios('No se pudo cargar la lista (' + e.message + ').'); - }); - } - - function actionsHtmlUsuario(u) { - var activo = u.activo !== false; - return '
' + - '' + - '' + - '' + - '
'; - } - - function editPanelHtmlUsuario(u) { - return '
' + - '
' + - '' + - '' + - '
' + - '
' + - '' + - '' + - '
' + - '' + - '' + - '
'; - } - - function renderUsuarios() { - var list = document.getElementById("usuarios-list"); - if (!usuarios.length) { - list.innerHTML = '
Sin usuarios todavía.
'; - return; - } - - list.innerHTML = usuarios.map(function (u) { - var activo = u.activo !== false; - var estadoHtml = activo - ? 'activo' - : 'inactivo'; - return '
' + - '
' + - '
Usuario
' + - '
' + u.usuario + '
' + - '
' + - '
' + - '
Perfil
' + - '
' + u.perfil + '
' + - '
' + - '
' + - '
Estado
' + - estadoHtml + - '
' + - '
' + - '
Creado
' + - '
' + fmtRelative(u.creado) + ' · ' + fmtClock(u.creado) + '
' + - '
' + - (editingUsuario === u.usuario ? editPanelHtmlUsuario(u) : actionsHtmlUsuario(u)) + - '
'; - }).join(''); - } - - document.getElementById("usuarios-list").addEventListener("click", function (e) { - var btn = e.target.closest("[data-usuario-action]"); - if (!btn) return; - var card = e.target.closest(".key-card"); - var usuario = card.getAttribute("data-usuario"); - var action = btn.getAttribute("data-usuario-action"); - var u = usuarios.find(function (uu) { return uu.usuario === usuario; }); - - if (action === "edit") { - editingUsuario = usuario; - renderUsuarios(); - } else if (action === "cancel-edit") { - editingUsuario = null; - renderUsuarios(); - } else if (action === "save-edit") { - var perfil = card.querySelector(".ep-perfil").value; - var passwordNueva = card.querySelector(".ep-password").value; - var body = { perfil: perfil }; - if (passwordNueva) body.password = passwordNueva; - fetch('/usuarios/' + encodeURIComponent(usuario), { - method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(body) - }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }) - .then(function () { editingUsuario = null; return cargarUsuarios(); }) - .catch(function (err) { mostrarErrorUsuarios('No se pudo editar: ' + err.message); }); - } else if (action === "toggle-activo") { - var nuevoActivo = !(u.activo !== false); - fetch('/usuarios/' + encodeURIComponent(usuario), { - method: 'PATCH', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ activo: nuevoActivo }) - }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }) - .then(function () { return cargarUsuarios(); }) - .catch(function (err) { mostrarErrorUsuarios('No se pudo cambiar el estado: ' + err.message); }); - } else if (action === "delete") { - abrirModalConfirmacion({ - titulo: "Eliminar usuario", - confirmValue: usuario, - accion: "Sí, eliminar", - accionEnCurso: "Eliminando…", - bodyHtml: '¿Eliminar el usuario ' + usuario + '? Esta acción no se puede deshacer — pierde acceso al panel inmediatamente.', - onConfirm: function () { - return fetch('/usuarios/' + encodeURIComponent(usuario), { method: 'DELETE' }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return r.json(); - }); - }, - onDone: cargarUsuarios - }); - } - }); - - var nuevoUsuarioInput = document.getElementById("f-nuevo-usuario"); - var nuevoUsuarioPasswordInput = document.getElementById("f-nuevo-usuario-password"); - var toggleNuevoUsuarioPassword = document.getElementById("toggle-nuevo-usuario-password"); - - toggleNuevoUsuarioPassword.addEventListener("click", function () { - var showing = nuevoUsuarioPasswordInput.type === "text"; - nuevoUsuarioPasswordInput.type = showing ? "password" : "text"; - toggleNuevoUsuarioPassword.textContent = showing ? "mostrar" : "ocultar"; - }); - - var addUsuarioToggler = crearTogglerInline("add-usuario-trigger", "add-usuario-form", "f-nuevo-usuario", function () { - nuevoUsuarioInput.value = ""; - nuevoUsuarioPasswordInput.value = ""; - nuevoUsuarioPasswordInput.type = "password"; - toggleNuevoUsuarioPassword.textContent = "mostrar"; - marcarCampoRequerido("field-nuevo-usuario", "hint-usuario-required", false); - marcarCampoRequerido("field-nuevo-usuario-password", "hint-usuario-password-required", false); - }); - - document.getElementById("add-usuario-trigger").addEventListener("click", addUsuarioToggler.abrir); - - document.getElementById("add-usuario-form").addEventListener("click", function (e) { - var btn = e.target.closest("[data-action]"); - if (!btn) return; - if (btn.getAttribute("data-action") === "cancel-new-usuario") addUsuarioToggler.cerrar(); - if (btn.getAttribute("data-action") === "save-new-usuario") guardarUsuarioNuevo(btn); - }); - - function guardarUsuarioNuevo(btn) { - var usuario = nuevoUsuarioInput.value.trim(); - var perfil = document.getElementById("f-nuevo-perfil").value; - var password = nuevoUsuarioPasswordInput.value; - - var usuarioVacio = !usuario; - var passwordVacia = !password; - marcarCampoRequerido("field-nuevo-usuario", "hint-usuario-required", usuarioVacio); - marcarCampoRequerido("field-nuevo-usuario-password", "hint-usuario-password-required", passwordVacia); - if (usuarioVacio || passwordVacia) return; - - btn.disabled = true; - - fetch('/usuarios', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ usuario: usuario, perfil: perfil, password: password }) - }) - .then(function (r) { - return r.json().then(function (data) { return { ok: r.ok, data: data }; }); - }) - .then(function (result) { - if (!result.ok) throw new Error(result.data.error || ('HTTP ' + result.status)); - addUsuarioToggler.cerrar(); - return cargarUsuarios(); - }) - .catch(function (e) { mostrarErrorUsuarios(e.message); }) - .finally(function () { btn.disabled = false; }); - } - - document.getElementById("groups").addEventListener("click", function (e) { - var btn = e.target.closest("[data-action]"); - if (!btn) return; - - var card = e.target.closest(".key-card"); - var provider = card.getAttribute("data-provider"); - var identificador = card.getAttribute("data-identificador"); - var action = btn.getAttribute("data-action"); - - if (action === "edit") { - editing = provider + '/' + identificador; - render(); - } else if (action === "cancel-edit") { - editing = null; - render(); - } else if (action === "save-edit") { - var cuenta = card.querySelector(".ep-cuenta").value.trim(); - var reset = card.querySelector(".ep-reset").value; - var nuevoId = card.querySelector(".ep-identificador").value.trim(); - var cambios = { cuenta_origen: cuenta, reset_segundos: reset }; - if (nuevoId && nuevoId !== identificador) cambios.identificador = nuevoId; - patchKey(provider, identificador, cambios) - .then(function () { editing = null; return cargarKeys(); }) - .catch(function (err) { mostrarErrorAccion('No se pudo editar: ' + err.message); }); - } else if (action === "toggle-activo") { - var k = keys.find(function (kk) { return kk.provider === provider && kk.identificador === identificador; }); - var nuevoActivo = !(k.activo !== false); - patchKey(provider, identificador, { activo: nuevoActivo }) - .then(function () { return cargarKeys(); }) - .catch(function (err) { mostrarErrorAccion('No se pudo cambiar el estado: ' + err.message); }); - } else if (action === "delete") { - abrirModalEliminar(provider, identificador); - } else if (action === "liberar") { - fetch('/keys/' + encodeURIComponent(provider) + '/' + encodeURIComponent(identificador) + '/liberar', { method: 'POST' }) - .then(function (r) { - if (!r.ok) return r.json().then(function (d) { throw new Error(d.error || ('HTTP ' + r.status)); }); - return cargarKeys(); - }) - .catch(function (err) { mostrarErrorAccion('No se pudo liberar: ' + err.message); }); - } - }); - - var deleteModalBackdrop = document.getElementById("delete-modal-backdrop"); - var deleteModalTitle = document.getElementById("delete-modal-title"); - var deleteModalBody = document.getElementById("delete-modal-body"); - var deleteModalLabel = document.getElementById("delete-modal-label"); - var deleteModalInput = document.getElementById("delete-modal-input"); - var deleteModalCancel = document.getElementById("delete-modal-cancel"); - var deleteModalConfirm = document.getElementById("delete-modal-confirm"); - - // Modal genérico de confirmación destructiva — "type to confirm" (pedido - // del Operador). Usado tanto para eliminar keys como revocar consumidores: - // pendingDelete = { confirmValue, accion, onConfirm, onDone }. - function abrirModalConfirmacion(opts) { - pendingDelete = opts; - deleteModalTitle.textContent = opts.titulo || "Confirmar"; - deleteModalBody.innerHTML = opts.bodyHtml; - deleteModalLabel.textContent = 'Escribí "' + opts.confirmValue + '" para confirmar'; - deleteModalInput.value = ""; - deleteModalBackdrop.classList.add("visible"); - deleteModalConfirm.textContent = opts.accion; - deleteModalConfirm.disabled = true; - deleteModalInput.focus(); - } - - // Qué pools pierden la key al eliminarla (P335/Fase 12): NEXXA la saca de todos, sin referencias colgadas - function avisoPoolsKey(provider, identificador) { - var k = keys.find(function (kk) { return kk.provider === provider && kk.identificador === identificador; }); - if (!k || !k.pools || !k.pools.length) return ''; - return '

⚠️ También sale de ' + k.pools.length + ' pool(s): ' + - k.pools.map(function (p) { return '' + esc(p.individuo) + ' · ' + esc(p.rol) + ''; }).join(', ') + '.'; - } - - function abrirModalEliminar(provider, identificador) { - abrirModalConfirmacion({ - titulo: "Eliminar key", - confirmValue: identificador, - accion: "Sí, eliminar", - accionEnCurso: "Eliminando…", - bodyHtml: '¿Eliminar ' + esc(identificador) + ' (' + esc(provider) + ')? Esta acción no se puede deshacer — el historial de uso en usos.log se conserva, pero la key deja de existir en el registro.' + - avisoPoolsKey(provider, identificador), - onConfirm: function () { return deleteKey(provider, identificador); }, - onDone: cargarKeys - }); - } - - function cerrarModalEliminar() { - pendingDelete = null; - deleteModalInput.value = ""; - deleteModalBackdrop.classList.remove("visible"); - } - - deleteModalInput.addEventListener("input", function () { - deleteModalConfirm.disabled = !pendingDelete || deleteModalInput.value !== pendingDelete.confirmValue; - }); - - deleteModalCancel.addEventListener("click", cerrarModalEliminar); - - deleteModalBackdrop.addEventListener("click", function (e) { - if (e.target === deleteModalBackdrop) cerrarModalEliminar(); - }); - - document.addEventListener("keydown", function (e) { - if (e.key === "Escape" && deleteModalBackdrop.classList.contains("visible")) cerrarModalEliminar(); - }); - - deleteModalConfirm.addEventListener("click", function () { - if (!pendingDelete) return; - var accionTexto = pendingDelete.accion; - var onDone = pendingDelete.onDone; - deleteModalConfirm.disabled = true; - deleteModalConfirm.textContent = pendingDelete.accionEnCurso; - pendingDelete.onConfirm() - .then(function () { - cerrarModalEliminar(); - return onDone(); - }) - .catch(function (err) { - deleteModalConfirm.disabled = false; - deleteModalConfirm.textContent = accionTexto; - mostrarErrorAccion('No se pudo completar: ' + err.message); - }); - }); - - function render() { - var groups = document.getElementById("groups"); - groups.innerHTML = ""; - - var byProvider = {}; - keys.forEach(function (k) { - (byProvider[k.provider] = byProvider[k.provider] || []).push(k); - }); - - var providers = Object.keys(byProvider).sort(); - // Los conteos por estado salen de /resumen (cargarResumen, P337/Fase 2), no de un cálculo acá - document.getElementById("stat-total").textContent = keys.length; - document.getElementById("stat-providers").textContent = providers.length; - - renderGauges(byProvider); - - // Autocompletar "Cuenta de origen" con las ya cargadas (P204/Fase4, - // pedido del Operador) — evita retipear siempre desde cero. - // nativo, sin JS de más: el navegador ya sabe filtrar/sugerir solo. - var cuentasList = document.getElementById("cuentas-origen-conocidas"); - if (cuentasList) { - var cuentas = Array.from(new Set(keys.map(function (k) { return k.cuenta_origen; }).filter(Boolean))).sort(); - cuentasList.innerHTML = cuentas.map(function (c) { return ''; }).join(''); - } - - if (!keys.length) { - groups.innerHTML = '
Sin keys registradas todavía. Usá la pestaña «Alta de key» para cargar la primera.
'; - return; - } - - providers.forEach(function (provider) { - var title = document.createElement("div"); - title.className = "group-title"; - title.innerHTML = '' + provider + '' + byProvider[provider].length + ''; - groups.appendChild(title); - - var list = document.createElement("div"); - list.className = "card-list"; - - byProvider[provider] - .slice() - // Orden por último uso, no por disponible_desde (P204/Fase4, pedido - // del Operador: la vista tiene que reflejar cómo se CONSUME el pool, - // no un campo administrativo) — la que menos se usó recientemente - // aparece primero, mismo criterio que Registro.disponible en el - // backend (rotación) — así la lista muestra literalmente "quién - // sigue" en el orden real de reparto. - .sort(function (a, b) { - var uaA = a.ultimo_uso ? new Date(a.ultimo_uso).getTime() : 0; - var uaB = b.ultimo_uso ? new Date(b.ultimo_uso).getTime() : 0; - return uaA - uaB; - }) - .forEach(function (k) { - var keyId = k.provider + '/' + k.identificador; - var activo = k.activo !== false; - // P204/Fase3: agotada (disponible_desde futuro, agotamiento real - // reportado por el consumidor) y reservada (reservado_hasta futuro, - // contención corta al dispensar) son estados distintos — una key - // puede estar reservada sin estar agotada, y viceversa nunca (agotada - // siempre libera la reserva). Reflejar exactamente el mismo filtro - // que usa Registro.disponible en el backend (Armonía Integral). - // P337/Fase 2: el estado lo calcula el servidor (k.estado/hasta/por/motivo); acá no se recalcula - var bloqueada = ['en_uso', 'en_pausa', 'agotada'].indexOf(k.estado) >= 0; - var isNew = lastCreated && lastCreated.provider === k.provider && lastCreated.identificador === k.identificador; - var card = document.createElement("div"); - card.className = "key-card" + (isNew ? " is-new" : ""); - card.setAttribute("data-provider", k.provider); - card.setAttribute("data-identificador", k.identificador); - - // Estado + su timing van juntos (P204/Fase4, rediseño de columnas - // por propósito real — el timing es una aclaración del estado, no - // un dato independiente) — pill arriba, "vence en X"/"libera en X" - // como subtexto, sin ocupar una columna propia. - var asignadaHtml; - if (k.estado === 'en_uso' && k.por) { - asignadaHtml = '
' + esc(k.por) + '
'; - } else if (k.ultimo_individuo) { - asignadaHtml = '
último: ' + esc(k.ultimo_individuo) + '
'; - } else { - asignadaHtml = '
— libre —
'; - } - - // Último uso (P204/Fase4, pedido del Operador): NEXXA sirve keys — - // el dato que más importa operativamente es cuándo se dispensó por - // última vez, no cuándo "vence" algo. Es también la señal visual - // de que la rotación (Fase4/4.6) funciona: ninguna key debería - // quedar mucho más atrás que las demás del mismo provider. - var ultimoUsoHtml = k.ultimo_uso - ? '' + fmtRelative(k.ultimo_uso) + ' · ' + fmtClock(k.ultimo_uso) - : 'nunca'; - - card.innerHTML = - '
' + - '
Identificador
' + - '
' + esc(k.identificador) + '
' + - '
' + esc(k.provider) + ' · cuenta: ' + esc(k.cuenta_origen) + '
' + - chipsPools(k.pools) + - '
' + - '
' + - '
Estado
' + - estadoHtml(k) + - '
' + - '
' + - '
Último uso
' + - '
' + ultimoUsoHtml + '
' + - '
' + - '
' + - '
Asignada a
' + - asignadaHtml + - '
' + - (editing === keyId ? editPanelHtml(k) : actionsHtml(k, keyId, activo, activo && bloqueada)); - - list.appendChild(card); - }); - - groups.appendChild(list); - }); - } - - // Gauges circulares por provider (P204/Fase4, estilo resumen de Proxmox) — - // distribución real del pool: qué % de las APIs registradas es de cada - // proveedor (no "% en uso", que confundía — un gauge de uso solo tiene - // sentido comparado contra el resto del mismo provider, no como % del - // total, y con un solo provider siempre daba una lectura rara). Se - // calcula de los datos ya cargados de /keys, sin fetch propio. - function renderGauges(byProvider) { - var el = document.getElementById("gauges"); - if (!el) return; - - var providers = Object.keys(byProvider).sort(); - if (!providers.length) { - el.innerHTML = ''; - return; - } - - var totalKeys = providers.reduce(function (sum, p) { - return sum + byProvider[p].filter(function (k) { return k.activo !== false; }).length; - }, 0); - - el.innerHTML = providers.map(function (provider) { - var count = byProvider[provider].filter(function (k) { return k.activo !== false; }).length; - var pct = totalKeys ? Math.round((count / totalKeys) * 100) : 0; - return gaugeHtml(pct, provider, count + '/' + totalKeys); - }).join(''); - } - - function gaugeHtml(pct, label, sub) { - var r = 46, c = Math.round(2 * Math.PI * r); - var offset = Math.round(c - (pct / 100) * c); - // Distribución, no alerta — a diferencia de un gauge de "% en uso", acá - // un valor alto no es malo (un solo provider = 100%, es normal), así - // que no escala a rojo/naranja como si fuera una advertencia. - var color = 'var(--accent)'; - return ( - '
' + - '' + - '' + - '' + - '' + pct + '%' + - '' + sub + '' + - '' + - '
' + label + '
' + - '
' - ); - } - - // Actividad reciente + gráfico de dispensas por día (P204/Fase4) — ambos - // proporcionados al volumen real de usos.log (hoy escaso): la lista muestra - // lo que hay sin inventar agregados, el gráfico crece solo con el uso real. - // Una fila del registro (P337/Fase 2): la usan "Últimos eventos" y la sección Registro - function filaEvento(u) { - return ( - '' + - '' + fmtClock(u.en) + '
' + fmtRelative(u.en) + '
' + - '' + esc(u.provider) + '/' + esc(u.identificador) + '' + - '' + eventoTexto(u.clase || u.evento, u.texto) + '' + - '' + esc(u.individuo || '—') + '' + - '' + esc(u.motivo || '') + '' + - '' + (u.hasta ? cuando(u.hasta) : '') + '' + - '' - ); - } - - function tablaEventos(usos, vacio) { - if (!usos.length) return '
' + vacio + '
'; - return '' + - '' + usos.map(filaEvento).join('') + '
CuándoKeyQué pasóQuiénDetalleHasta
'; - } - - function statHtml(etiqueta, valor, clase, ayuda) { - return '
' + etiqueta + - '
' + valor + '
'; - } - - // Dashboard desde /resumen (P337/Fase 2): estados AHORA (todos, también en 0) y lo que pasó en 24 h - function cargarResumen() { - return pedirJson('/resumen?horas=24').then(function (r) { - TEXTOS_EVENTO = r.textos || TEXTOS_EVENTO; - document.getElementById('stats-ahora').innerHTML = ESTADOS_ORDEN.map(function (e) { - var u = ESTADO_UI[e]; - return statHtml('' + u.texto + '', r.ahora[e] || 0); - }).join(''); - var ev = r.eventos; - var cambios = ev.alta + ev.editada + ev.renombrada + ev.baja + ev['liberada-admin']; - document.getElementById('stats-24h').innerHTML = - statHtml('Entregas', ev.dispensada, '', 'keys entregadas a un consumidor') + - statHtml('Pausas por límite', ev.pausada, 'warn', 'el proveedor contestó límite por minuto: la key vuelve sola en minutos') + - statHtml('Agotamientos de cuota', ev.agotada, 'warn', 'cuota del ciclo agotada: vuelve al reiniciarse la cuota') + - statHtml('Cambios de admin', cambios, '', 'altas, ediciones, renombres, bajas y liberaciones por admin') + - (ev['agotada-previa'] ? statHtml('Bloqueos sin clasificar', ev['agotada-previa'], '', - 'registros anteriores a NEXXA 2.0.0: no distinguen una pausa por límite de una cuota agotada') : ''); - renderPorKey(r.por_key); - }).catch(function () { /* cargarKeys ya avisa los problemas de conexión */ }); - } - - function renderPorKey(filas) { - var el = document.getElementById('por-key'); - if (!el) return; - if (!filas.length) { el.innerHTML = '
Sin keys registradas.
'; return; } - el.innerHTML = '' + - '' + filas.map(function (k) { - var ult = k.ultimo_evento; - return '' + - '' + - '' + - ''; - }).join('') + '
KeyEstadoEntregasPausasAgotamientosÚltimo evento
' + esc(k.provider) + '/' + esc(k.identificador) + '' + estadoHtml(k) + '' + k.eventos.dispensada + '' + k.eventos.pausada + '' + k.eventos.agotada + '' + (ult ? eventoTexto(ult.clase || ult.evento, ult.texto) + '
' + fmtRelative(ult.en) + '
' : '—') + '
'; - } - - function renderBarChart(entregas) { - var el = document.getElementById("bar-chart"); - if (!el) return; - - var dias = []; - for (var i = 6; i >= 0; i--) { - var d = new Date(); - d.setDate(d.getDate() - i); - dias.push(d.toLocaleDateString('sv-SE')); // AAAA-MM-DD en hora LOCAL (antes UTC: el día cambiaba a las 21 h) - } - var counts = {}; - dias.forEach(function (d) { counts[d] = 0; }); - entregas.forEach(function (u) { - var d = new Date(u.en).toLocaleDateString('sv-SE'); - if (counts.hasOwnProperty(d)) counts[d]++; - }); - var max = Math.max.apply(null, dias.map(function (d) { return counts[d]; }).concat([1])); - - el.innerHTML = dias.map(function (d) { - var h = Math.max(2, Math.round((counts[d] / max) * 60)); - return ( - '
' + - '
' + - '
' + d.slice(5) + '
' + - '
' - ); - }).join(''); - } - - // Sección Registro (P337/Fase 2): filtros que el SERVIDOR aplica (/usos); las opciones salen de los datos reales - function opcionesRegistro() { - var ev = document.getElementById('reg-evento'); - if (ev.options.length === 1 && Object.keys(TEXTOS_EVENTO).length) { - // 'agotada-previa' es una clase calculada (agotada sin hasta), no un código guardado: no se filtra por él - Object.keys(TEXTOS_EVENTO).filter(function (e) { return e !== 'agotada-previa'; }) - .forEach(function (e) { ev.add(new Option(eventoTexto(e), e)); }); - } - var sel = document.getElementById('reg-key'); - var actual = sel.value; - sel.length = 1; - keys.map(function (k) { return k.provider + '/' + k.identificador; }).sort().forEach(function (ref) { sel.add(new Option(ref, ref)); }); - sel.value = actual; - } - - // reintento: los textos llegan con /resumen; si todavía no están se piden UNA vez (sin bucle si /resumen falla) - function cargarRegistro(reintento) { - if (!Object.keys(TEXTOS_EVENTO).length && reintento !== true) { - return cargarResumen().then(function () { return cargarRegistro(true); }); - } - opcionesRegistro(); - var q = ['horas=' + encodeURIComponent(document.getElementById('reg-horas').value), 'limit=500']; - var ev = document.getElementById('reg-evento').value; - var key = document.getElementById('reg-key').value; - var quien = document.getElementById('reg-individuo').value.trim(); - if (ev) q.push('evento=' + encodeURIComponent(ev)); - if (key) { - var partes = key.split('/'); - q.push('provider=' + encodeURIComponent(partes[0]), 'identificador=' + encodeURIComponent(partes.slice(1).join('/'))); - } - if (quien) q.push('individuo=' + encodeURIComponent(quien)); - return pedirJson('/usos?' + q.join('&')).then(function (usos) { - document.getElementById('reg-cuenta').textContent = usos.length + (usos.length === 500 ? '+ (los 500 más recientes)' : '') + ' evento(s)'; - document.getElementById('registro-lista').innerHTML = tablaEventos(usos, 'Ningún evento con esos filtros.'); - }).catch(function (e) { - document.getElementById('registro-lista').innerHTML = '
No se pudo leer el registro (' + esc(e.message) + ').
'; - }); - } - - ['reg-horas', 'reg-evento', 'reg-key'].forEach(function (id) { - document.getElementById(id).addEventListener('change', function () { cargarRegistro(); }); - }); - document.getElementById('reg-individuo').addEventListener('keydown', function (e) { if (e.key === 'Enter') cargarRegistro(); }); - document.querySelector('[data-ir-registro]').addEventListener('click', function (e) { e.preventDefault(); selectSection('registro'); }); - - // Últimos eventos y entregas por día desde /usos YA filtrado en el servidor (antes: los últimos 100 eventos de todo - // tipo, y el gráfico contaba como entrega cualquier evento) - function cargarUsos() { - return Promise.all([ - pedirJson('/usos?horas=24&limit=12').then(function (usos) { - document.getElementById('actividad-lista').innerHTML = tablaEventos(usos, 'Nada en las últimas 24 h.'); - }), - pedirJson('/usos?evento=dispensada&horas=168&limit=2000').then(renderBarChart) - ]).catch(function () { /* cargarKeys ya avisa los problemas de conexión */ }); - } - - function cargarKeys() { - return fetch('/keys') - .then(function (r) { - if (!r.ok) throw new Error('HTTP ' + r.status); - return r.json(); - }) - .then(function (data) { - keys = data; - actualizarProvidersConocidos(); - loadError.classList.remove('visible'); - nodePill.classList.remove('error'); - nodePillText.textContent = 'servicio activo · puerto 4568'; - render(); - }) - .catch(function (e) { - loadError.textContent = 'No se pudo cargar el estado de las keys (' + e.message + ').'; - loadError.classList.add('visible'); - nodePill.classList.add('error'); - nodePillText.textContent = 'sin conexión'; - }); - } - - // Sugerencias de provider para el alta (P335/Fase 7): los que ya tienen keys + los habituales, sin lista fija - var PROVIDERS_HABITUALES = ["gemini", "deepseek", "groq", "openai", "anthropic"]; - function actualizarProvidersConocidos() { - var vistos = {}; - PROVIDERS_HABITUALES.concat(keys.map(function (k) { return k.provider; })).forEach(function (p) { vistos[p] = true; }); - document.getElementById("providers-conocidos").innerHTML = Object.keys(vistos).sort().map(function (p) { - return ''; - }).join(''); - } - - var toggleValor = document.getElementById("toggle-valor"); - var valorInput = document.getElementById("f-valor"); - toggleValor.addEventListener("click", function () { - var showing = valorInput.type === "text"; - valorInput.type = showing ? "password" : "text"; - toggleValor.textContent = showing ? "mostrar" : "ocultar"; - }); - - // Fichas inline de alta ("+" sobre la lista, P201/Fase3 — reemplazan las - // pestañas separadas de alta: mismo estilo visual que las fichas ya - // cargadas, se abren/cierran in-place). abrir/cerrar es el mismo - // mecanismo para keys y consumidores — un solo helper, no duplicado. - function crearTogglerInline(triggerId, formId, primerCampoId, limpiarFn) { - var trigger = document.getElementById(triggerId); - var form = document.getElementById(formId); - return { - abrir: function () { - trigger.style.display = "none"; - form.classList.add("visible"); - document.getElementById(primerCampoId).focus(); - }, - cerrar: function () { - if (limpiarFn) limpiarFn(); - form.classList.remove("visible"); - trigger.style.display = ""; - } - }; - } - - // Toggle de error+hint de un campo requerido — mismo patrón repetido en - // el alta de keys y en el alta de consumidores, extraído una sola vez. - function marcarCampoRequerido(fieldId, hintId, vacio) { - document.getElementById(fieldId).classList.toggle("has-error", vacio); - document.getElementById(hintId).classList.toggle("visible", vacio); - } - - var addKeyErrorBanner = document.getElementById("add-key-error-banner"); - var addKeyErrorTitle = document.getElementById("add-key-error-title"); - - function limpiarAddKeyForm() { - document.getElementById("f-identificador").value = ""; - document.getElementById("f-cuenta-origen").value = ""; - document.getElementById("f-pool").value = ""; - valorInput.value = ""; - valorInput.type = "password"; - toggleValor.textContent = "mostrar"; - marcarCampoRequerido("field-identificador", "hint-id-required", false); - document.getElementById("hint-id-taken").classList.remove("visible"); - marcarCampoRequerido("field-cuenta-origen", "hint-cuenta-required", false); - marcarCampoRequerido("field-valor", "hint-valor-required", false); - addKeyErrorBanner.classList.remove("visible"); - } - - var addKeyToggler = crearTogglerInline("add-key-trigger", "add-key-form", "f-identificador", limpiarAddKeyForm); - - document.getElementById("add-key-trigger").addEventListener("click", addKeyToggler.abrir); - - document.getElementById("add-key-form").addEventListener("click", function (e) { - var btn = e.target.closest("[data-action]"); - if (!btn) return; - if (btn.getAttribute("data-action") === "cancel-new") addKeyToggler.cerrar(); - if (btn.getAttribute("data-action") === "save-new") guardarKeyNueva(btn); - }); - - function guardarKeyNueva(btn) { - var identificador = document.getElementById("f-identificador").value.trim(); - var cuentaOrigen = document.getElementById("f-cuenta-origen").value.trim(); - var valor = valorInput.value; - var provider = document.getElementById("f-provider").value.trim().toLowerCase(); - var resetSegundos = document.getElementById("f-reset").value; - - var idVacio = !identificador; - var idTaken = !idVacio && keys.some(function (k) { return k.provider === provider && k.identificador === identificador; }); - - marcarCampoRequerido("field-identificador", "hint-id-required", idVacio); - document.getElementById("hint-id-taken").classList.toggle("visible", idTaken); - document.getElementById("field-identificador").classList.toggle("has-error", idVacio || idTaken); - marcarCampoRequerido("field-cuenta-origen", "hint-cuenta-required", !cuentaOrigen); - marcarCampoRequerido("field-valor", "hint-valor-required", !valor); - addKeyErrorBanner.classList.remove("visible"); - - if (!provider) { - addKeyErrorTitle.textContent = 'Falta el provider (ej. gemini, deepseek).'; - addKeyErrorBanner.classList.add("visible"); - } - if (!provider || idVacio || idTaken || !cuentaOrigen || !valor) return; - - btn.disabled = true; - - fetch('/alta', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - provider: provider, - identificador: identificador, - cuenta_origen: cuentaOrigen, - reset_segundos: resetSegundos, - valor: valor - }) - }) - .then(function (r) { - return r.json().then(function (data) { return { ok: r.ok, status: r.status, data: data }; }); - }) - .then(function (result) { - if (!result.ok) { - throw new Error(result.data.error || ('HTTP ' + result.status)); - } - - lastCreated = { provider: provider, identificador: identificador }; - var pool = document.getElementById("f-pool").value; - var asignar = Promise.resolve(); - if (pool) { - var partes = pool.split('/'); - asignar = pedirJson('/pools/' + encodeURIComponent(partes[0]) + '/' + partes[1], { - method: 'POST', headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ provider: provider, identificador: identificador }) - }); - } - return asignar.then(function () { - addKeyToggler.cerrar(); - return cargarKeys(); - }); - }) - .catch(function (e) { - addKeyErrorTitle.textContent = e.message; - addKeyErrorBanner.classList.add("visible"); - }) - .finally(function () { - btn.disabled = false; - }); - } - - // ---------- Pools por individuo: mente y red (P335/Fase 7) ---------- - // Lee /pools (estado de cada key de cada pool, nunca valores) y /consumidores (individuos con token: aparecen - // aunque todavía no tengan pool). Asignar/quitar solo admin; el backend lo valida igual (ME-683). - var poolsError = document.getElementById("pools-error"); - var poolsLista = document.getElementById("pools-lista"); - var ROLES_POOL = [ - { rol: "mente", titulo: "🧠 Mente", ayuda: "piensa y opera" }, - { rol: "red", titulo: "🪫 Red", ayuda: "solo aviso de batería baja" } - ]; - - function pedirJson(url, opts) { - return fetch(url, opts).then(function (r) { - return r.json().then(function (d) { - if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status)); - return d; - }); - }); - } - - function cargarPools() { - poolsError.classList.remove('visible'); - return Promise.all([pedirJson('/pools'), pedirJson('/consumidores')]) - .then(function (res) { - consumidores = res[1] || []; - renderConsumidores(); // el resumen de pools de Individuos y el Dashboard quedan al día - renderPools(res[0].individuos || {}, consumidores); - return cargarKeys(); // los chips de pools de cada key (sección APIs) quedan al día tras cualquier cambio - }) - .catch(function (e) { - poolsError.textContent = 'No se pudieron cargar los pools (' + e.message + ').'; - poolsError.classList.add('visible'); - }); - } - - // Misma presentación que APIs (P337/Fase 2): una sola función de estado - function pillEstado(f) { - return estadoHtml(f); - } - - // Estado de la vista (P335/Fase 12): lo último que se leyó y qué columna se está editando ('individuo|rol') - var ultimoPools = {}; - var ultimosConsumidores = []; - var editandoPool = null; - - function renderPools(pools, consumidoresLista) { - ultimoPools = pools; - ultimosConsumidores = consumidoresLista; - var nombres = {}; - consumidoresLista.forEach(function (c) { nombres[c.individuo] = true; }); - Object.keys(pools).forEach(function (n) { nombres[n] = true; }); - var lista = Object.keys(nombres).sort(); - if (!lista.length) { - poolsLista.innerHTML = '
Sin individuos con token todavía. Dalos de alta en «Individuos».
'; - return; - } - - poolsLista.innerHTML = lista.map(function (ind) { - var columnas = ROLES_POOL.map(function (r) { - var filas = (pools[ind] && pools[ind][r.rol]) || []; - var cuerpo = editandoPool === ind + '|' + r.rol ? editorPoolHtml(filas) : vistaPoolHtml(filas, r); - return '
' + - '
' + r.titulo + ' · ' + r.ayuda + '' + - (esAdmin && editandoPool !== ind + '|' + r.rol - ? '' : '') + - '
' + cuerpo + '
'; - }).join(''); - return '
' + - '
Individuo
' + esc(ind) + '
' + - columnas + '
'; - }).join(''); - } - - // Ver (R): cada key con su estado; el admin puede moverla al otro rol (⇄) o quitarla (✕) - function vistaPoolHtml(filas, r) { - if (!filas.length) return '
— vacío: NEXXA responde pool_vacio —
'; - var otro = r.rol === 'mente' ? 'Red' : 'Mente'; - return filas.map(function (f) { - return '
' + - '
' + esc(f.identificador) + ' ' + esc(f.provider) + '
' + - '
' + pillEstado(f) + '
' + - (esAdmin - ? '
' + - '' + - '
' - : '') + - '
'; - }).join(''); - } - - // Editar (C/U/D en un paso): todas las keys con casillas, agrupadas por provider; Guardar deja el pool exactamente así - function editorPoolHtml(filas) { - var enPool = {}; - filas.forEach(function (f) { enPool[f.provider + '/' + f.identificador] = true; }); - var porProvider = {}; - keys.forEach(function (k) { (porProvider[k.provider] = porProvider[k.provider] || []).push(k); }); - var grupos = Object.keys(porProvider).sort().map(function (prov) { - return '
' + esc(prov) + '
' + - porProvider[prov].map(function (k) { - var ref = k.provider + '/' + k.identificador; - return ''; - }).join('') + '
'; - }).join(''); - return '
' + (grupos || '
No hay keys cargadas.
') + - '
' + - '' + - '
'; - } - - function errorPools(err) { - poolsError.textContent = 'No se pudo cambiar el pool: ' + err.message; - poolsError.classList.add('visible'); - } - - function guardarPool(base, refs) { - return pedirJson(base, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ refs: refs }) }) - .then(function () { editandoPool = null; return cargarPools(); }); - } - - poolsLista.addEventListener("click", function (e) { - var btn = e.target.closest("[data-action]"); - if (!btn) return; - var card = btn.closest(".pool-card"); - var col = btn.closest(".pool-col"); - var ind = card.getAttribute("data-individuo"); - var rol = col.getAttribute("data-rol"); - var base = '/pools/' + encodeURIComponent(ind) + '/' + rol; - var accion = btn.getAttribute("data-action"); - var item = btn.closest(".pool-key"); - var refItem = item ? encodeURIComponent(item.getAttribute("data-provider")) + '/' + encodeURIComponent(item.getAttribute("data-identificador")) : null; - - if (accion === "pool-editar") { - editandoPool = ind + '|' + rol; - renderPools(ultimoPools, ultimosConsumidores); - return; - } - if (accion === "pool-cancelar") { - editandoPool = null; - renderPools(ultimoPools, ultimosConsumidores); - return; - } - if (accion === "pool-guardar") { - var refs = Array.prototype.map.call(col.querySelectorAll('.pool-editor input:checked'), function (c) { return c.value; }); - if (!refs.length && ((ultimoPools[ind] || {})[rol] || []).length) { - // Vaciar es destructivo: confirmación escribiendo el nombre del individuo (mismo modal que eliminar una key) - abrirModalConfirmacion({ - titulo: "Vaciar pool", - confirmValue: ind, - accion: "Sí, vaciar", - accionEnCurso: "Vaciando…", - bodyHtml: '¿Dejar vacío el pool ' + esc(rol) + ' de ' + esc(ind) + '? Mientras esté vacío, NEXXA le responde pool_vacio cuando pida por ese rol.', - onConfirm: function () { return guardarPool(base, []); }, - onDone: function () { return Promise.resolve(); } - }); - return; - } - btn.disabled = true; - guardarPool(base, refs).catch(function (err) { btn.disabled = false; errorPools(err); }); - return; - } - - var pedido; - if (accion === "pool-mover") { - pedido = pedirJson(base + '/' + refItem + '/mover', { method: 'POST' }); - } else if (accion === "pool-quitar") { - pedido = pedirJson(base + '/' + refItem, { method: 'DELETE' }); - } else { - return; - } - btn.disabled = true; - pedido.then(cargarPools).catch(function (err) { btn.disabled = false; errorPools(err); }); - }); - })(); diff --git a/servicios/nexxa/web/js/login.js b/servicios/nexxa/web/js/login.js deleted file mode 100644 index 0c91d9e5..00000000 --- a/servicios/nexxa/web/js/login.js +++ /dev/null @@ -1,43 +0,0 @@ -(function () { - "use strict"; - - var form = document.getElementById("login-form"); - var usuarioInput = document.getElementById("f-usuario"); - var passwordInput = document.getElementById("f-password"); - var submitBtn = document.getElementById("login-submit"); - var errorEl = document.getElementById("login-error"); - var versionEl = document.getElementById("version-tag"); - - if (versionEl) { - fetch("/version") - .then(function (r) { return r.json(); }) - .then(function (d) { versionEl.textContent = "v" + d.version; }) - .catch(function () {}); - } - - form.addEventListener("submit", function (e) { - e.preventDefault(); - errorEl.classList.remove("visible"); - submitBtn.disabled = true; - - fetch("/login", { - method: "POST", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ usuario: usuarioInput.value, password: passwordInput.value }) - }) - .then(function (r) { - return r.json().then(function (data) { return { ok: r.ok, data: data }; }); - }) - .then(function (result) { - if (!result.ok) throw new Error(result.data.error || "Usuario o password incorrectos"); - location.reload(); - }) - .catch(function (err) { - errorEl.textContent = err.message; - errorEl.classList.add("visible"); - passwordInput.value = ""; - passwordInput.focus(); - submitBtn.disabled = false; - }); - }); -})(); diff --git a/servicios/nexxa/web/login.html b/servicios/nexxa/web/login.html deleted file mode 100644 index 3abb7a7d..00000000 --- a/servicios/nexxa/web/login.html +++ /dev/null @@ -1,108 +0,0 @@ - - - - - -NEXXA · Ingresar - - - - - - - -