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
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:
co-authored by
Claude Opus 5.5
GEMMA
parent
50ac0d0fdf
commit
a60758875d
@@ -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*
|
||||
@@ -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`.
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
1.3.0
|
||||
@@ -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)
|
||||
@@ -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})"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -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/<provider|mente|red></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/<provider|mente|red></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
@@ -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;
|
||||
});
|
||||
});
|
||||
})();
|
||||
@@ -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>
|
||||
Reference in New Issue
Block a user