feat(nexxa): NEXXA versionada en dtic-DIIAA (1.3.0): pools por individuo mente/red, API por rol y gestión desde nexxa-web
Tests ADN / test (push) Canceled after 0s

- Base: código de producción de srvv-nexxa (1.2.1), importado y verificado por hash (P335/F3)
- Pools por individuo (lib_pools): mente y red, mezclan proveedores, keys compartidas o exclusivas
- API: /disponible/mente|red y /estado por rol, pool_vacio explícito, /pools (CRUD admin), liberar admin
- Revertir el agotada propio + motivo y quién la agotó (de P334/F4)
- nexxa-web: sección Pools, motivo y botón Liberar, provider libre con sugerencias, escape de texto externo
- Convención REG002: lib_*, cli_*, tool_humo_pool; contratos externos con su nombre
- Suite local sobre copia aislada: humo HTTP, pools, revertir; servidor_prueba para mirar la web

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-Authored-By: GEMMA <noreply@gemma.dtic>
This commit is contained in:
Ricardo Monla
2026-10-04 16:42:13 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 50ac0d0fdf
commit a60758875d
31 changed files with 5653 additions and 0 deletions
+12
View File
@@ -0,0 +1,12 @@
# 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*
+36
View File
@@ -0,0 +1,36 @@
# 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/<x>_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 <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).
Plan vigente: `dtic-GEMMA/_docs/DIIAA/p_P335_nexxa-pools-por-individuo-mente-y-red-con-gestion-web.md`.
+151
View File
@@ -0,0 +1,151 @@
# 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
+1
View File
@@ -0,0 +1 @@
1.3.0
+11
View File
@@ -0,0 +1,11 @@
#!/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)
+47
View File
@@ -0,0 +1,47 @@
#!/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 <nombre> [--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
@@ -0,0 +1,37 @@
#!/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 <nombre> [--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
@@ -0,0 +1,37 @@
#!/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 <provider> <identificador> <cuenta_origen> <reset_segundos>
# (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 <provider> <identificador> <cuenta_origen> <reset_segundos>'
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
)
puts "Registrado: #{provider} → #{identificador} (cuenta: #{cuenta_origen})"
+20
View File
@@ -0,0 +1,20 @@
#!/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
+202
View File
@@ -0,0 +1,202 @@
# 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'
module Nexxa
module Auth
USERS_FILE = File.expand_path('.usuarios.json', __dir__).freeze
SESSIONS_FILE = File.expand_path('.sessions.json', __dir__).freeze
PBKDF2_ITER = 100_000
SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable
PERFILES_VALIDOS = %w[admin operador].freeze
# ---------- Usuarios ----------
def self.leer_usuarios
return [] unless File.exist?(USERS_FILE)
JSON.parse(File.read(USERS_FILE))
rescue JSON::ParserError
[]
end
def self.guardar_usuarios(lista)
File.write(USERS_FILE, JSON.pretty_generate(lista) + "\n")
File.chmod(0o600, USERS_FILE)
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)
lista = leer_usuarios
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
}
guardar_usuarios(lista)
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)
lista = leer_usuarios
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
guardar_usuarios(lista)
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)
lista = leer_usuarios
existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip }
guardar_usuarios(lista) if existia
!existia.nil?
end
def self.admins_activos
leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false }
end
# ---------- Sesiones ----------
def self.leer_sesiones
return {} unless File.exist?(SESSIONS_FILE)
JSON.parse(File.read(SESSIONS_FILE))
rescue JSON::ParserError
{}
end
def self.guardar_sesiones(sesiones)
File.write(SESSIONS_FILE, JSON.pretty_generate(sesiones) + "\n")
File.chmod(0o600, SESSIONS_FILE)
end
def self.crear_sesion(usuario, perfil)
token = SecureRandom.hex(32)
sesiones = leer_sesiones
sesiones[token] = {
'usuario' => usuario,
'perfil' => perfil,
'expira' => (Time.now + SESSION_TTL).iso8601
}
guardar_sesiones(sesiones)
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?
sesiones = leer_sesiones
entrada = sesiones[token]
return nil unless entrada
if Time.parse(entrada['expira']) < Time.now
sesiones.delete(token)
guardar_sesiones(sesiones)
return nil
end
{ 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] }
end
def self.sesion_valida?(token)
!sesion(token).nil?
end
def self.cerrar_sesion(token)
sesiones = leer_sesiones
existia = sesiones.delete(token)
guardar_sesiones(sesiones) if existia
!existia.nil?
end
end
end
+54
View File
@@ -0,0 +1,54 @@
# 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'
module Nexxa
module Checkins
STATE_FILE = File.expand_path('checkins.json', __dir__).freeze
def self.leer
return {} unless File.exist?(STATE_FILE)
JSON.parse(File.read(STATE_FILE))
rescue JSON::ParserError
{}
end
def self.guardar(state)
File.write(STATE_FILE, JSON.pretty_generate(state) + "\n")
File.chmod(0o600, 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)
state = leer
state[individuo] = {
'estado' => estado.to_s,
'detalle' => detalle,
'ultimo_reporte' => Time.now.utc.iso8601
}
guardar(state)
state[individuo]
end
def self.estado(individuo)
leer[individuo]
end
def self.listar
leer
end
end
end
+74
View File
@@ -0,0 +1,74 @@
# 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
+38
View File
@@ -0,0 +1,38 @@
# 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
+132
View File
@@ -0,0 +1,132 @@
# 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'
module Nexxa
module Pools
STATE_FILE = File.expand_path('pools.json', __dir__).freeze
ROLES = %w[mente red].freeze
module_function
def leer
return { 'individuos' => {} } unless File.exist?(STATE_FILE)
d = JSON.parse(File.read(STATE_FILE))
d['individuos'] ||= {}
d
rescue JSON::ParserError
{ 'individuos' => {} }
end
def guardar(state)
tmp = "#{STATE_FILE}.tmp-#{Process.pid}"
File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(state) + "\n") }
File.rename(tmp, STATE_FILE)
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)
state = leer
pool = (state['individuos'][individuo] ||= {})[rol] ||= []
r = ref(provider, identificador)
pool << r unless pool.include?(r)
guardar(state)
pool
end
# Quita una key de un pool. => true si estaba.
def quitar(individuo:, rol:, provider:, identificador:)
validar!(individuo, rol)
state = leer
pool = state.dig('individuos', individuo, rol)
return false unless pool&.delete(ref(provider, identificador))
state['individuos'][individuo].delete(rol) if pool.empty?
state['individuos'].delete(individuo) if state['individuos'][individuo].empty?
guardar(state)
true
end
# Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas).
def olvidar_key(provider:, identificador:)
state = leer
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? }
guardar(state) if cambio
cambio
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/<nombre> 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
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
+330
View File
@@ -0,0 +1,330 @@
# 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'
module Nexxa
module Registro
STATE_FILE = File.expand_path('registro.json', __dir__).freeze
# 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
def self.leer
if File.exist?(STATE_FILE)
JSON.parse(File.read(STATE_FILE))
else
{ 'keys' => [] }
end
rescue JSON::ParserError
{ 'keys' => [] }
end
def self.guardar(state)
File.write(STATE_FILE, JSON.pretty_generate(state) + "\n")
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.
def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil)
state = leer
ahora = Time.now
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
existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
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
guardar(state)
state
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)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
entrada['cuenta_origen'] = cuenta_origen unless cuenta_origen.nil?
entrada['reset_segundos'] = reset_segundos unless reset_segundos.nil?
entrada['activo'] = activo unless activo.nil?
guardar(state)
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:)
state = leer
existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador }
guardar(state) if existia
!existia.nil?
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:)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
entrada['ultimo_uso'] = ahora.iso8601(3)
entrada['ultimo_individuo'] = individuo
entrada['reservado_por'] = individuo
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
guardar(state)
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada')
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)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora)
entrada['disponible_desde'] = ahora.iso8601(3)
entrada['agotada_por'] = nil
guardar(state)
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'revertida')
return entrada
end
raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo
case estado
when 'sana'
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
when 'liberada'
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
when 'agotada'
reset_segundos = entrada['reset_segundos']
raise "Key #{provider}/#{identificador} sin reset_segundos persistido — no se puede reportar agotada" unless reset_segundos
entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3)
entrada['agotada_por'] = individuo
entrada['motivo_agotada'] = motivo.to_s[0, 200] unless motivo.to_s.empty?
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'agotada')
else
raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)"
end
guardar(state)
entrada
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:)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
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
guardar(state)
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
def self.estado_de(keys, ahora = Time.now)
keys.map do |k|
estado = if k['activo'] == false then 'inactiva'
elsif Time.parse(k['disponible_desde']) > ahora then 'agotada'
elsif k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora then 'reservada'
else 'disponible'
end
{ 'provider' => k['provider'], 'identificador' => k['identificador'], 'estado' => estado,
'libera_en' => (estado == 'agotada' ? k['disponible_desde'] : nil),
'reservado_por' => (estado == 'reservada' ? k['reservado_por'] : nil),
'agotada_por' => (estado == 'agotada' ? k['agotada_por'] : nil),
'motivo' => (estado == 'agotada' ? k['motivo_agotada'] : nil),
'ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo'] }
end
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)
de_refs(refs).select { |k| k['activo'] != false }.min_by { |k| Time.parse(k['disponible_desde']) }
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)
leer['keys']
.select { |k| k['provider'] == provider && k['activo'] != false }
.min_by { |k| Time.parse(k['disponible_desde']) }
end
end
end
+117
View File
@@ -0,0 +1,117 @@
# 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'
module Nexxa
module Tokens
STATE_FILE = File.expand_path('tokens.json', __dir__).freeze
def self.leer
if File.exist?(STATE_FILE)
JSON.parse(File.read(STATE_FILE))
else
{ 'tokens' => [] }
end
rescue JSON::ParserError
{ 'tokens' => [] }
end
def self.guardar(state)
File.write(STATE_FILE, JSON.pretty_generate(state) + "\n")
File.chmod(0o600, STATE_FILE)
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)
state = leer
state['tokens'].reject! { |t| t['individuo'] == individuo }
state['tokens'] << {
'individuo' => individuo,
'token_hash' => Digest::SHA256.hexdigest(token),
'creado' => Time.now.iso8601
}
guardar(state)
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)
state = leer
existia = state['tokens'].reject! { |t| t['individuo'] == individuo }
guardar(state) if existia
!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)
state = leer
entrada = state['tokens'].find { |t| t['individuo'] == individuo }
raise "Individuo sin token: #{individuo}" unless entrada
entrada['clave_publica_pem'] = clave_publica_pem
guardar(state)
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
+46
View File
@@ -0,0 +1,46 @@
# 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'
module Nexxa
module Usos
LOG_FILE = File.expand_path('usos.log', __dir__).freeze
# evento (P204/Fase3): 'dispensada' (reserva al entregar la key) o 'agotada'
# (el consumidor reportó agotamiento real) — default compat con llamadas
# previas a Fase3 (todas eran dispensas).
def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada')
linea = {
'provider' => provider,
'identificador' => identificador,
'individuo' => individuo,
'evento' => evento,
'en' => en.iso8601
}
File.open(LOG_FILE, 'a') { |f| f.puts(linea.to_json) }
end
# Historial más reciente primero, opcionalmente filtrado por key
def self.historial(provider: nil, identificador: nil, limit: 50)
return [] unless File.exist?(LOG_FILE)
lineas = File.readlines(LOG_FILE).filter_map do |l|
JSON.parse(l)
rescue JSON::ParserError
nil
end
lineas.select! { |l| l['provider'] == provider } if provider
lineas.select! { |l| l['identificador'] == identificador } if identificador
lineas.last(limit).reverse
end
end
end
+15
View File
@@ -0,0 +1,15 @@
#!/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 <provider>\""
exit 1
end
puts Nexxa::Router.procesar(estimulo)
+44
View File
@@ -0,0 +1,44 @@
# 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 <provider>" (ej. "disponible gemini")
def self.procesar(estimulo)
partes = estimulo.to_s.strip.split(/\s+/)
return "ERROR: estímulo no reconocido — formato esperado: 'disponible <provider>'" 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
+915
View File
@@ -0,0 +1,915 @@
#!/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/<provider|mente|red> → 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/<p>/<id>/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
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
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).
server.mount_proc '/' do |req, res|
res.status = 200
res.content_type = 'text/html; charset=utf-8'
res.body = File.read(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'
res.body = { version: version_actual }.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/<provider>/<id> — editar cuenta_origen/reset_segundos/activo
# DELETE /keys/<provider>/<id> — 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
res.body = Nexxa::Registro.todas.to_json
end
# POST /keys/<provider>/<identificador>/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/<provider>/<identificador>/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/<provider>/<identificador>' }.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
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
)
res.status = 200
res.body = entrada.reject { |k, _| k == 'valor_cifrado' }.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'
partes = partes_de(req)
if partes.size != 2
res.status = 400
res.body = { error: 'Uso: DELETE /keys/<provider>/<identificador>' }.to_json
return
end
provider, identificador = partes
borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador)
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/<individuo>/<rol> body {provider, identificador}
# DELETE /pools/<individuo>/<rol>/<provider>/<identificador>
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)
return responder(res, 400, { error: 'Uso: POST /pools/<individuo>/<mente|red> {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
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
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/<individuo>/<mente|red>/<provider>/<identificador>' }) 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.
server.mount_proc '/usos' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.historial(limit: 100).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/<individuo> — 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
res.body = Nexxa::Tokens.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
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/<individuo>' }.to_json
return
end
revocado = Nexxa::Tokens.revocar(individuo)
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/<usuario> — editar perfil/activo/password, body {perfil, activo, password}
# DELETE /usuarios/<usuario> — 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/<usuario>' }.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/<usuario>' }.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/<provider> — 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/<provider>/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: <nombre> 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 <token>)' }.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/<provider|mente|red>/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'
siguiente = Nexxa::Pools.disponible(individuo, nombre) # del mismo pool (rol) o del mismo provider
if siguiente
sp = siguiente['provider']
valor_siguiente = Nexxa::Registro.revelar(provider: sp, identificador: siguiente['identificador'])
if valor_siguiente
Nexxa::Registro.reservar(provider: sp, identificador: siguiente['identificador'], individuo: individuo)
resp[:siguiente] = { provider: sp, identificador: siguiente['identificador'] }.merge(empaquetar_valor(individuo, valor_siguiente))
end
end
end
res.status = 200
res.content_type = 'application/json'
res.body = resp.to_json
next
end
# GET /disponible/<provider>/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/<provider|mente|red>/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/<provider|mente|red>' }.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 }
key = Nexxa::Pools.disponible(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 = Nexxa::Registro.revelar(provider: provider, identificador: key['identificador'])
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
# Reserva corta de contención (P204/Fase3, D045 §8) — ya no asume agotamiento
# completo al dispensar (eso lo decide el consumidor vía POST .../reportar);
# solo evita que 2 consumidores reciban la misma key mientras uno la prueba.
Nexxa::Registro.reservar(provider: provider, identificador: key['identificador'], individuo: individuo)
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 <token>)' }.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']
)
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 <token>)' }.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/<individuo> (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
+245
View File
@@ -0,0 +1,245 @@
#!/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|
keys = Nexxa::Registro.leer['keys'].select { |k| k['provider'] == provider }
keys.each do |k|
agotada = Time.parse(k['disponible_desde']) > ahora
reservada = !agotada && k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
estado = if k['activo'] == false then 'desactivada'
elsif agotada then 'agotada'
elsif reservada then 'reservada'
else 'disponible'
end
icono = { 'disponible' => '🟢', 'reservada' => '🔵', 'agotada' => '🔴', 'desactivada' => '⚪' }[estado]
puts " #{icono} #{provider}/#{k['identificador']}: #{estado}"
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)
+96
View File
@@ -0,0 +1,96 @@
# 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
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
def test_sin_token_ni_sesion
assert_equal 401, pedir('get', '/disponible/mente')[0]
assert_equal 401, pedir('get', '/pools')[0]
end
end
@@ -0,0 +1,59 @@
# 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]].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}")
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'))
pid = Process.spawn('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
+106
View File
@@ -0,0 +1,106 @@
# 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 }.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', 'agotada_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
end
+56
View File
@@ -0,0 +1,56 @@
# 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 } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, '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
def test_estado_del_pool_sin_valores_y_con_los_cuatro_estados
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)
est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] }
assert_equal %w[reservada agotada disponible inactiva], %w[g-01 g-02 g-03 g-off].map { |i| est[i]['estado'] }
assert_equal 'gemma-f1', est['g-02']['agotada_por']
refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') }
end
end
+16
View File
@@ -0,0 +1,16 @@
# 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)
File diff suppressed because it is too large Load Diff
+285
View File
@@ -0,0 +1,285 @@
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>NEXXA · Panel de administración</title>
<link rel="stylesheet" href="/css/estilos.css" />
</head>
<body>
<div class="app-shell">
<aside class="sidebar" id="sidebar">
<div class="sidebar-header">
<div class="brand-block">
<div class="brand-mark">NEXXA</div>
<div class="brand-sub mono" id="version-tag">—</div>
</div>
<button type="button" class="sidebar-toggle-btn" id="sidebar-toggle" aria-label="Colapsar barra lateral" title="Colapsar/expandir">☰</button>
</div>
<nav class="sidebar-nav" aria-label="Secciones de NEXXA">
<button class="nav-item" data-section="dashboard" aria-current="page"><span class="nav-icon">📊</span><span class="nav-label">Dashboard</span></button>
<button class="nav-item" data-section="apis"><span class="nav-icon">🔑</span><span class="nav-label">APIs</span></button>
<button class="nav-item" data-section="nodos"><span class="nav-icon">🖥</span><span class="nav-label">Individuos</span></button>
<button class="nav-item" data-section="pools"><span class="nav-icon">🧩</span><span class="nav-label">Pools</span></button>
<button class="nav-item" data-section="usuarios" id="nav-usuarios" style="display: none;"><span class="nav-icon">👤</span><span class="nav-label">Usuarios</span></button>
</nav>
</aside>
<main class="main-area">
<header class="topbar">
<h1 class="page-title mono" id="page-title">Dashboard</h1>
<div style="display: flex; align-items: center; gap: 10px;">
<span class="timing" id="sesion-actual"></span>
<div class="node-pill" id="node-pill"><span class="dot"></span> <span id="node-pill-text">conectando…</span></div>
<button type="button" class="action-btn" id="logout-btn">Cerrar sesión</button>
</div>
</header>
<section id="section-dashboard" class="section active">
<div class="stats">
<div class="stat">
<div class="stat-label">Keys registradas</div>
<div class="stat-value mono" id="stat-total">—</div>
</div>
<div class="stat">
<div class="stat-label">Providers</div>
<div class="stat-value mono" id="stat-providers">—</div>
</div>
<div class="stat">
<div class="stat-label">Agotadas ahora</div>
<div class="stat-value warn mono" id="stat-agotadas">—</div>
</div>
<div class="stat">
<div class="stat-label">Reservadas ahora</div>
<div class="stat-value info mono" id="stat-reservadas">—</div>
</div>
<div class="stat">
<div class="stat-label">Consumidores</div>
<div class="stat-value mono" id="stat-consumidores">—</div>
</div>
</div>
<div class="dash-panels">
<div class="panel">
<div class="panel-title">Distribución de APIs por proveedor</div>
<div class="gauge-row" id="gauges"></div>
</div>
<div class="panel">
<div class="panel-title">Dispensas por día (últimos 7 días)</div>
<div class="bar-chart" id="bar-chart"></div>
</div>
<div class="panel panel-tall">
<div class="panel-title">Reportes por individuo</div>
<div id="reportes-individuo"></div>
</div>
<div class="panel panel-tall">
<div class="panel-title">Actividad reciente</div>
<div id="actividad-lista"></div>
</div>
</div>
</section>
<section id="section-apis" class="section">
<div class="notice">
<span>🔒</span>
<span><strong>Solo metadata.</strong> 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 <span class="mono">GET /disponible/&lt;provider|mente|red&gt;</span>.</span>
</div>
<div id="load-error" class="notice error"></div>
<div class="error-banner" id="add-key-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo registrar la key</span>
<span class="body" id="add-key-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-key-trigger">
<span class="add-plus">+</span> Nueva key
</button>
<div class="key-card inline-add-form" id="add-key-form">
<div class="inline-add-row">
<div class="inline-add-field">
<label for="f-provider">Provider</label>
<input id="f-provider" class="mono" type="text" value="gemini" autocomplete="off" list="providers-conocidos" />
<datalist id="providers-conocidos"></datalist>
</div>
<div class="inline-add-field" id="field-identificador">
<label for="f-identificador">Identificador</label>
<input id="f-identificador" class="mono" type="text" placeholder="gemini-03" autocomplete="off" />
<span class="hint hint-conditional" id="hint-id-required">Obligatorio.</span>
<span class="hint hint-conditional" id="hint-id-taken">Ya existe.</span>
</div>
<div class="inline-add-field" id="field-cuenta-origen">
<label for="f-cuenta-origen">Cuenta de origen</label>
<input id="f-cuenta-origen" class="mono" type="text" placeholder="cuenta ante el proveedor" autocomplete="off" list="cuentas-origen-conocidas" />
<datalist id="cuentas-origen-conocidas"></datalist>
<span class="hint hint-conditional" id="hint-cuenta-required">Obligatorio.</span>
</div>
<div class="inline-add-field">
<label for="f-reset">Estimación de reset (respaldo)</label>
<select id="f-reset" class="mono">
<option value="86400">24 horas</option>
<option value="3600">1 hora</option>
<option value="604800">7 días</option>
</select>
</div>
<div class="card-icon-actions">
<button type="button" class="icon-btn primary" data-action="save-new" title="Guardar">💾</button>
<button type="button" class="icon-btn" data-action="cancel-new" title="Cancelar">✕</button>
</div>
</div>
<div class="inline-add-row" style="grid-template-columns: 1fr auto;">
<div class="inline-add-field secret-field" id="field-valor">
<label for="f-valor">Valor de la key</label>
<input id="f-valor" type="password" placeholder="Pegar el valor real" autocomplete="off" />
<button type="button" class="secret-toggle" id="toggle-valor">mostrar</button>
<span class="hint hint-conditional" id="hint-valor-required">Obligatorio.</span>
</div>
</div>
<p class="inline-add-hint">🛈 Se cifra al llegar a NEXXA — no se vuelve a mostrar en pantalla una vez cargada, ni en esta mini-app ni en <span class="mono">apids chat</span>.</p>
<p class="inline-add-hint">🛈 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.</p>
</div>
<div id="groups"></div>
</section>
<section id="section-pools" class="section">
<div class="notice">
<span>🧩</span>
<span><strong>Pools por individuo (P335).</strong> Cada individuo piensa y opera con las keys de su pool <b>Mente</b> y usa las de su pool <b>Red</b> 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 <span class="mono">GET /disponible/mente</span> o <span class="mono">/disponible/red</span>; con un pool vacío NEXXA responde <span class="mono">pool_vacio</span>, nunca cae a otra key.</span>
</div>
<div class="notice error" id="pools-error"></div>
<div id="pools-lista"></div>
</section>
<section id="section-nodos" class="section">
<div class="notice">
<span>🔑</span>
<span><strong>Individuos con acceso.</strong> Cada uno tiene un token propio para pedir keys vía <span class="mono">GET /disponible/&lt;provider|mente|red&gt;</span>. El token se muestra en claro una única vez, al generarlo — nunca se vuelve a mostrar después.</span>
</div>
<div class="notice">
<span>📡</span>
<span><strong>Check-in proactivo (P216).</strong> 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.</span>
</div>
<div class="confirm-banner token-banner" id="token-banner">
<span>🔑</span>
<span>
<span class="title" id="token-banner-title"></span>
<span class="body">
<span class="mono token-value" id="token-banner-value"></span>
<button type="button" class="action-btn primary" id="token-copy-btn">Copiar</button>
</span>
<span class="body">Guardalo ahora (ej. en candados) — no se vuelve a mostrar en esta pantalla.</span>
</span>
</div>
<div class="error-banner" id="consumidores-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo completar la operación</span>
<span class="body" id="consumidores-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-consumidor-trigger">
<span class="add-plus">+</span> Nuevo consumidor
</button>
<div class="consumidor-card inline-add-form" id="add-consumidor-form">
<div class="inline-add-row" style="grid-template-columns: 1fr auto;">
<div class="inline-add-field" id="field-nuevo-individuo">
<label for="f-nuevo-individuo">Individuo</label>
<input id="f-nuevo-individuo" class="mono" type="text" placeholder="abby" autocomplete="off" />
<span class="hint hint-conditional" id="hint-individuo-required">Obligatorio.</span>
</div>
<div class="card-icon-actions">
<button type="button" class="icon-btn primary" data-action="save-new-consumidor" title="Generar token">💾</button>
<button type="button" class="icon-btn" data-action="cancel-new-consumidor" title="Cancelar">✕</button>
</div>
</div>
<p class="inline-add-hint">🛈 Si el individuo ya tenía token, esto lo reemplaza (rotación) — el viejo deja de servir.</p>
</div>
<div id="consumidores-list"></div>
</section>
<section id="section-usuarios" class="section">
<div class="notice">
<span>👤</span>
<span><strong>Gestión de usuarios.</strong> Solo perfil <span class="mono">admin</span> puede crear, editar o eliminar usuarios del panel. El último admin activo no se puede degradar ni eliminar.</span>
</div>
<div class="error-banner" id="usuarios-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo completar la operación</span>
<span class="body" id="usuarios-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-usuario-trigger">
<span class="add-plus">+</span> Nuevo usuario
</button>
<div class="key-card inline-add-form" id="add-usuario-form">
<div class="inline-add-row">
<div class="inline-add-field" id="field-nuevo-usuario">
<label for="f-nuevo-usuario">Usuario</label>
<input id="f-nuevo-usuario" class="mono" type="text" placeholder="rmonla" autocomplete="off" />
<span class="hint hint-conditional" id="hint-usuario-required">Obligatorio.</span>
</div>
<div class="inline-add-field">
<label for="f-nuevo-perfil">Perfil</label>
<select id="f-nuevo-perfil" class="mono">
<option value="operador">operador</option>
<option value="admin">admin</option>
</select>
</div>
<div class="inline-add-field secret-field" id="field-nuevo-usuario-password">
<label for="f-nuevo-usuario-password">Password inicial</label>
<input id="f-nuevo-usuario-password" type="password" placeholder="Password" autocomplete="off" />
<button type="button" class="secret-toggle" id="toggle-nuevo-usuario-password">mostrar</button>
<span class="hint hint-conditional" id="hint-usuario-password-required">Obligatorio.</span>
</div>
<div class="card-icon-actions">
<button type="button" class="icon-btn primary" data-action="save-new-usuario" title="Crear">💾</button>
<button type="button" class="icon-btn" data-action="cancel-new-usuario" title="Cancelar">✕</button>
</div>
</div>
<p class="inline-add-hint">🛈 El usuario nuevo cambia su password desde acá mismo (editar) cuando quiera — no hay auto-reset.</p>
</div>
<div id="usuarios-list"></div>
</section>
</main>
</div>
<div class="modal-backdrop" id="delete-modal-backdrop">
<div class="modal" role="alertdialog" aria-modal="true" aria-labelledby="delete-modal-title">
<div class="modal-icon">⚠️</div>
<h3 id="delete-modal-title">Eliminar key</h3>
<p class="modal-body" id="delete-modal-body"></p>
<div class="modal-field">
<label for="delete-modal-input" id="delete-modal-label"></label>
<input type="text" id="delete-modal-input" class="mono" autocomplete="off" />
</div>
<div class="modal-actions">
<button type="button" class="action-btn" id="delete-modal-cancel">Cancelar</button>
<button type="button" class="action-btn confirm" id="delete-modal-confirm" disabled>Sí, eliminar</button>
</div>
</div>
</div>
<script src="/js/app.js"></script>
</body>
</html>
File diff suppressed because it is too large Load Diff
+43
View File
@@ -0,0 +1,43 @@
(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;
});
});
})();
+108
View File
@@ -0,0 +1,108 @@
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>NEXXA · Ingresar</title>
<link rel="stylesheet" href="/css/estilos.css" />
<style>
.login-shell {
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
padding: 20px;
}
.login-card {
width: 100%;
max-width: 340px;
border: 1px solid var(--border);
background: var(--surface);
border-radius: 14px;
padding: 28px;
box-shadow: var(--shadow);
}
.login-card h1 {
font-size: 18px;
margin: 0 0 4px;
}
.login-card .sub {
color: var(--text-faint);
font-size: 12.5px;
margin: 0 0 22px;
}
.login-field { margin-bottom: 16px; }
.login-field label {
display: block;
font-size: 11.5px;
text-transform: uppercase;
letter-spacing: 0.06em;
color: var(--text-faint);
margin-bottom: 6px;
}
.login-field input {
width: 100%;
padding: 10px 12px;
border-radius: 8px;
border: 1px solid var(--border);
background: var(--bg);
color: var(--text);
font-size: 14px;
font-family: inherit;
}
.login-submit {
width: 100%;
appearance: none;
border: 1px solid var(--accent-border);
background: var(--accent-soft);
color: var(--accent-strong);
font-size: 13.5px;
font-weight: 700;
padding: 10px;
border-radius: 8px;
cursor: pointer;
font-family: inherit;
}
.login-submit:hover { background: var(--accent-border); }
.login-submit:disabled { opacity: 0.5; cursor: not-allowed; }
.login-error {
display: none;
color: var(--danger);
font-size: 12.5px;
margin: -6px 0 16px;
}
.login-error.visible { display: block; }
</style>
</head>
<body>
<div class="login-shell">
<div class="login-card">
<h1 class="mono">NEXXA</h1>
<p class="sub">Panel de administración — acceso restringido</p>
<form id="login-form">
<div class="login-field">
<label for="f-usuario">Usuario</label>
<input id="f-usuario" type="text" autocomplete="username" autofocus />
</div>
<div class="login-field">
<label for="f-password">Password</label>
<input id="f-password" type="password" autocomplete="current-password" />
</div>
<p class="login-error" id="login-error"></p>
<button type="submit" class="login-submit" id="login-submit">Ingresar</button>
</form>
<p class="version-tag mono" id="version-tag" style="text-align:center; margin: 16px 0 0;">—</p>
</div>
</div>
<script src="/js/login.js"></script>
</body>
</html>