refactor(nexxa): el código se muda a dtic-GEMMA/_docs/DIIAA/_servers/srvv-nexxa/servicios/NEXXA/app-web (convención de servicios por servidor, P338/F1); queda una nota de dónde sigue
Tests ADN / test (push) Canceled after 0s

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

Co-Authored-By: GEMMA <noreply@gemma.dtic>
This commit is contained in:
Ricardo Monla
2026-10-05 16:12:51 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 577b5f9698
commit d106601946
40 changed files with 10 additions and 7276 deletions
-17
View File
@@ -1,17 +0,0 @@
# Estado y secretos de NEXXA: viven SOLO en el nodo (srvv-nexxa:/opt/nexxa), nunca en el repo (Regla de Oro 15).
.env
*.conf
organismo/.master_key
organismo/.usuarios.json
organismo/.sessions.json
organismo/registro.json
organismo/tokens.json
organismo/checkins.json
organismo/pools.json
organismo/*.log
*.bak*
organismo/COMMIT
# Motor archivo de Nexxa::Estado (P335/Fase 17): bloqueos de mutar, temporales de escritura atómica y respaldos de cli_estado
organismo/*.lock
organismo/*.tmp-*
organismo/bkp_estado_*.tgz
+10
View File
@@ -0,0 +1,10 @@
# NEXXA se mudó
Desde el 2026-10-05 (P338/Fase 1, convención de servicios por servidor) el código de NEXXA vive en el repo
**dtic-GEMMA**, junto a la ficha del servicio:
dtic-GEMMA/_docs/DIIAA/_servers/srvv-nexxa/servicios/NEXXA/
NEXXA.md ficha del servicio
app-web/ el código (lo que antes estaba acá)
El historial de commits hasta la mudanza queda en este repo (dtic-DIIAA). Se despliega con `gemma nexxa desplegar`.
-42
View File
@@ -1,42 +0,0 @@
# NEXXA — broker de API keys del ecosistema (servicio DIIAA)
NEXXA administra el pool de API keys (Gemini, DeepSeek, …) que consumen GEMMA y los individuos F1: dispensa una key
por consulta, cifrada de punta a punta para el consumidor, y recibe el reporte de salud de cada key. Se gestiona desde
**nexxa-web** (`web/`, panel con usuarios admin/operador) y se consume por su API HTTP (`organismo/server.rb`, :4568).
## Origen y versión
- **Versión vigente:** `organismo/VERSION` (fuente única; nexxa-web la muestra en `/version`).
- **Metamorfosis (2026-10-04, P335):** nació como el individuo `rm-apid06-nexxa` del linaje apids (repo `rm-APIDs`,
P201/P204/P205/P238). Pasa a ser el servicio `srvv-nexxa` del ámbito DIIAA: es la misma NEXXA, evolucionada.
- **Base de este repo:** el código que corría en producción el 2026-10-04 (versión 1.2.1), importado y verificado por
hash contra el nodo (`gemma git importar:verificar`, 23/23 iguales). El repo `rm-APIDs` había quedado atrasado desde
P201 (6 archivos distintos o ausentes).
## Estructura (convención REG002, P335/Fase 9)
- `organismo/lib_*.rb`: módulos (registro, pools, tokens, auth, usos, checkins, cripto, envelope).
- `organismo/cli_*.rb`: CLIs de emergencia en el nodo (`cli_admin`, `cli_consumidor`, `cli_registrar`).
- `organismo/tool_humo_pool.rb`: humo que corre EN el nodo contra el registro real (provider descartable).
- Contratos externos con su nombre de siempre: `server.rb` (lo arranca systemd) y el chasis F1 `chat.rb`, `latido.rb`,
`nexxa.rb`, `router.rb` (los usa `gemma individuos chat`, igual en todos los individuos).
- `test/`: suite local sobre una copia aislada con estado falso (`ruby test/<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).
- **Estado en su Postgres propio** (P335/Fase 17, decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8
caiga): todo pasa por `organismo/lib_estado.rb` (`Nexxa::Estado`), con motor `archivo` (JSON 0600, el de siempre y el
de los tests) o `pg` (base `nexxa` local, socket peer con el usuario del servicio, sin contraseña), elegido EXPLÍCITO con
`NEXXA_ESTADO=pg` en un drop-in systemd de los dos servicios. `mutar` es leer-modificar-guardar atómico y la dispensa
elige y reserva la key en un solo paso. Pasar de un motor al otro: `organismo/cli_estado.rb migrar|verificar|exportar`,
que desde GEMMA corre `gemma nexxa estado:pg --accion preparar|activar|revertir`.
Plan vigente: `dtic-GEMMA/_docs/DIIAA/p_P335_nexxa-pools-por-individuo-mente-y-red-con-gestion-web.md`.
-151
View File
@@ -1,151 +0,0 @@
# Germen — Individuo Circulatorio (rm-apid06-nexxa)
## Entregar este archivo como primer mensaje a la IA ejecutora del nacimiento
> Este germen NO es el de OpenClaw (Miguel, r-WEBs, PEGGY, ABBY). Aquellos hacen
> nacer un agente LLM-céntrico con gateway y canal conversacional. **Tampoco es**
> el de RUBBY, que aunque es chasis F1 nativo determinístico en runtime, sí lleva
> un Arquitecto (LLM) para génesis offline de piezas nuevas. **NEXXA nace sin
> ningún LLM, en ninguna capa, ni siquiera para su propia génesis** (decisión del
> Operador, P200/Fase2) — el organismo más minimalista del linaje hasta hoy.
> Reutiliza el *proceso* de nacimiento de RUBBY (checkpoints por etapa,
> separación script/individuo, secrets por env, gate entre etapas), no su
> *contenido*.
---
## Tu misión
Hacer nacer el **organismo mínimo viable** de rotación/fallback de API keys para
el equipo F1. De cara afuera, NEXXA responde consultas de sus pares vía
`apids chat` sobre qué key/provider está disponible ahora; por dentro es un
registro de estado (cuotas por provider) y una lógica de decisión puramente
determinística — sin capa de razonamiento en ningún punto del camino.
**El diseño ya está hecho — no lo reinventes.** El delta de dominio completo
vive en `_docs/RM-LABs/rm-APIDs/D045_diseno-nexxa-f1.md` (repo dtic-GEMMA), y el
modelo F1 base en `D025`. Tu trabajo es **materializarlo**, no rediseñarlo. Si
algo del diseño no cierra contra la realidad del hábitat, lo reportás y esperás
decisión — no improvisás una variante.
**Principio rector — diseño como objetivo, no receta:** este germen te da el *qué*
(el organismo a lograr, sus restricciones, su criterio de vida). El *cómo*
(estructura exacta de los archivos Ruby, comandos) lo investigás y resolvés vos
contra el hábitat real.
---
## Etapa 1 — Relevamiento (antes de tocar nada)
**Hábitat:**
- La LXC `rm-apid06-nexxa` en srv-pmox2 (VMID y recursos definidos en la corrida
de creación — ver Fase 3 del plan P200). Confirmá que existe, que arranca y que
tenés acceso SSH a ella.
- Ruby disponible dentro de la LXC. Es el único sustrato — no hay Node/OpenClaw
acá.
- NEXXA no necesita salida propia a internet para su función central (consulta
estado de cuotas que ya le llegaron por registro, no llama a los providers
directamente para verificar salud, al menos en el alcance mínimo de este
nacimiento — D045 §3 deja el contrato exacto a cerrar en esta misma fase).
**Secrets — protocolo estricto, sin excepciones (ME-293):**
- NEXXA no tiene key LLM propia (no hay Arquitecto). Los secrets que sí maneja
son las **keys de terceros que registra en su base** (Gemini/Groq/… de otros
individuos) — nunca en el `.conf` versionado, siempre en `.env` o vía candados,
nunca en argv (ME-293).
- Verificás presencia de secrets contando, sin mostrar valores.
Al cerrar el relevamiento: resumen (sin valores de secrets) y confirmación explícita
del operador antes de la Etapa 2.
---
## Etapa 2 — El organismo a materializar (el objetivo, no la receta)
Del diseño D045, dos órganos — ninguno con LLM:
1. **Registro de cuotas** (`registro.json` o similar — nombre exacto a definir
contra el hábitat) — una sola fuente de verdad. Cada entrada: `provider`,
`email`/identificador de la key, `dueño` (individuo consumidor o
`compartida`), `disponible_desde` (mismo cálculo que `apirot.rb`,
`ultimo_uso + reset`). **Delta sobre apirot** (D045/P200 Fase2-2.3): NEXXA
nace con registro propio y limpio, inspirado en el concepto de apirot pero no
dependiente de su código ni de su archivo — apirot.rb sigue existiendo tal
cual para uso interno de GEMMA.
2. **Router de consulta** (`maestro.rb` o equivalente mínimo) — matching exacto
`estímulo → respuesta de estado`, cero semántica en runtime, cero LLM. Ante
consulta "¿qué key uso para provider X?": busca en el registro la primera con
`disponible_desde <= ahora`; si ninguna, responde explícito y accionable (ej.
`GEMINI: agotado, próxima en 2h15m`), nunca silencioso (D045 §0, patrón ya
usado en el linaje).
**Sin Arquitecto, sin telemetría de génesis** (a diferencia de RUBBY/D025 §5):
no hay génesis reactiva que medir — si en el futuro hace falta una pieza nueva,
la escribe GEMMA/Operador a mano (ver nota de arquitectura compartida futura,
inbox ME de P200/Fase2).
**Restricciones heredadas del linaje (no las redescubras):**
- Gobernanza en código, nunca declarada solo en docs.
- El código del organismo vive versionado en el repo, no solo dentro del LXC
(srv-pmox2 es RAID0 sin redundancia).
- Nunca proxy/interceptor de tráfico de modelo, nunca MCP (restricciones
heredadas de P199, D045 §0).
Presentás el plan de materialización al operador y esperás aprobación antes de ejecutar.
---
## Etapa 3 — Nacimiento por checkpoints (reutiliza el patrón RUBBY/r-WEBs)
| `STAGE` | Qué nace | Gate de la etapa |
|---------|----------|------------------|
| `esqueleto` | Registro de cuotas + router, con 0 keys cargadas | El router arranca, lee registro vacío, responde "sin datos" ante una consulta de prueba |
| `conexion` | Canal `apids chat` verificado de punta a punta (patrón ya usado con ABBY/MIGUEL/RUBBY/PEGGY) + al menos 1 key real cargada (vía candados, no génesis) | Una consulta real por `apids chat` devuelve el estado correcto de esa key |
| `servicio` | Servicio systemd + `onboot=1` — el organismo revive tras reinicio del hipervisor | El servicio levanta el router solo; sobrevive a un reinicio de la LXC |
Secrets siempre por env exportado o candados. Al cerrar cada etapa: verificás,
registrás, y esperás OK del operador antes de la siguiente.
---
## Criterio de vida (qué es "nació bien")
El organismo está vivo cuando, sin intervención:
1. Responde una consulta real de un par (`apids chat`) sobre disponibilidad de
una key/provider, con el dato correcto.
2. Responde explícito y accionable cuando no hay ninguna key disponible (nunca
silencioso).
3. El servicio revive tras un reinicio de la LXC.
Primer caso real de aplicación (Fase 4 del plan P200): ABBY-F1 consulta a NEXXA
para sus 3 keys de Gemini — no es parte de este nacimiento, es el smoke test
posterior.
---
## individuo.conf (parámetros — el operador completa)
```conf
# Identidad
NOMBRE=NEXXA # bautizado por el Operador (2026-08-02) — concepto de switch/conmutación
MAQUINA=rm-apid06-nexxa
VMID=(a definir en Fase 3)
IP=(a definir en Fase 3 — requiere aprobación explícita del Operador, nunca se asigna sin OK)
HABITAT=srv-pmox2
# Función
PROPOSITO=rotación/fallback de API keys para el equipo F1 — alcance mínimo (no el "sistema circulatorio" amplio de ME-289)
# Sin Arquitecto — NEXXA no tiene key LLM propia, no genera piezas nuevas por su cuenta
```
---
## Referencias
- Delta de dominio: `_docs/RM-LABs/rm-APIDs/D045_diseno-nexxa-f1.md` (dtic-GEMMA)
- Modelo F1 base: `D025_diseno-fundacional-rubby-f1.md`
- Plan: `_docs/RM-LABs/p_P200_*.md` (dtic-GEMMA)
- Precedente de proceso: `rm-apid01-rubby/germen.md` (checkpoints, etapas, gate)
- ME: 289, 292, 293, 330, 331, 335, 417, 468
-1
View File
@@ -1 +0,0 @@
2.0.1
-11
View File
@@ -1,11 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# chat.rb — Entry point invocado por 'gemma apids chat' (chasis F1 nativo)
# Contrato: recibe el mensaje completo como ARGV[0], imprime texto plano
# (sin LLM, sin JSON — D045 §1/§4, cero semántica en runtime)
require_relative 'router'
texto = ARGV[0].to_s
puts Nexxa::Router.procesar(texto)
-47
View File
@@ -1,47 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_admin.rb — Bootstrap del primer usuario admin del panel web (P201/Fase4)
# Uso: ruby cli_admin.rb --usuario rmonla (crea, perfil admin)
# ruby cli_admin.rb --usuario rmonla --perfil operador
# ruby cli_admin.rb --usuario rmonla --rotar (rota su password)
# ruby cli_admin.rb --listar (metadata, sin hashes)
#
# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a
# través de GEMMA/candados ni de un agente — la password se imprime UNA vez
# acá y en ningún otro lugar (Regla 15). Una vez que existe al menos un admin,
# el alta de usuarios nuevos se hace normalmente desde el panel (sección
# Usuarios, gateada a perfil admin) — este script es solo para el bootstrap
# inicial o para recuperar acceso si quedan todos los admins bloqueados.
require_relative 'lib_auth'
args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] }
if ARGV.include?('--listar')
usuarios = Nexxa::Auth.listar
if usuarios.empty?
puts 'Sin usuarios todavía.'
else
usuarios.each { |u| puts "#{u['usuario']} (#{u['perfil']}) — #{u['activo'] == false ? 'inactivo' : 'activo'}" }
end
exit
end
usuario = args['usuario']
abort 'Uso: ruby cli_admin.rb --usuario <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
@@ -1,37 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_consumidor.rb — Alta/rotación de token de consumidor sin pasar por el panel (P204)
# Uso: ruby cli_consumidor.rb --individuo gemma (genera/rota token)
# ruby cli_consumidor.rb --listar (metadata, sin hashes)
# ruby cli_consumidor.rb --revocar --individuo gemma (revoca el acceso)
#
# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a
# través de GEMMA/candados ni de un agente — el token se imprime UNA vez acá
# y en ningún otro lugar (Regla 15).
require_relative 'lib_tokens'
args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] }
if ARGV.include?('--listar')
consumidores = Nexxa::Tokens.listar
if consumidores.empty?
puts 'Sin consumidores todavía.'
else
consumidores.each { |c| puts "#{c['individuo']} — creado #{c['creado']}" }
end
exit
end
individuo = args['individuo']
abort 'Uso: ruby cli_consumidor.rb --individuo <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
-162
View File
@@ -1,162 +0,0 @@
# frozen_string_literal: true
# cli_estado.rb — Mover el estado de NEXXA entre el motor archivo y su Postgres propio (P335/Fase 17)
# ==============================================================================
# Corre EN el nodo, en organismo/, con el usuario del servicio (autenticación peer al Postgres local):
# ruby cli_estado.rb esquema # crea las tablas estado y usos si faltan
# ruby cli_estado.rb migrar # archivos → pg. Respalda los JSON y usos.log en bkp_estado_<fecha>.tgz antes de
# # escribir. Idempotente: una segunda corrida informa 'igual' en todo y no escribe.
# ruby cli_estado.rb verificar # pg == archivos clave por clave y usos por cantidad; sale 1 si difiere
# ruby cli_estado.rb exportar # pg → archivos: la VUELTA ATRÁS (respaldo previo de lo que haya en disco)
# Independiente de NEXXA_ESTADO: lee y escribe los dos motores explícitamente. Nunca imprime valores, solo claves y
# conteos (el registro tiene los secretos cifrados y usuarios los hashes).
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_estado'
module Nexxa
module CliEstado
E = Nexxa::Estado
USO = 'ruby cli_estado.rb esquema|migrar|verificar|exportar'
# El drop-in que activa el motor pg en los servicios (lo escribe nexxa estado:pg --accion activar)
DROPIN = '/etc/systemd/system/nexxa.service.d/estado.conf'
module_function
def call(accion, salida: $stdout)
case accion
when 'esquema'
E.crear_esquema!
salida.puts('✅ tablas estado y usos listas')
0
when 'migrar' then migrar(salida)
when 'verificar' then verificar(salida)
when 'exportar' then exportar(salida)
else
salida.puts("Uso: #{USO}")
2
end
end
# Con el motor pg ya activo, los archivos quedaron viejos: migrar pisaría el estado vivo con ellos. Se niega (repetir
# 'activar' es seguro: frena acá y el trap vuelve a arrancar los servicios como estaban).
def pg_activo?(dropin = DROPIN)
File.exist?(dropin) && File.read(dropin).include?('NEXXA_ESTADO=pg')
end
def migrar(salida, dropin: DROPIN)
if pg_activo?(dropin)
salida.puts("❌ el motor pg ya está activo (#{dropin}): migrar pisaría el estado vivo con archivos viejos. " \
'Para volver a archivos: exportar (nexxa estado:pg --accion revertir)')
return 1
end
E.crear_esquema!
dif = diferencias
if dif.values.none?
salida.puts('✅ igual: pg ya coincide con los archivos, nada que migrar')
return 0
end
salida.puts("🗄 respaldo: #{respaldar}")
E::ARCHIVOS.each_key do |clave|
next salida.puts(" = #{clave}: igual") unless dif[clave]
E.pg_guardar(clave, E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave]))
salida.puts(" → #{clave}: migrada")
end
if dif['usos']
n_pg = contar_usos_pg
unless n_pg.zero?
salida.puts("❌ usos: pg ya tiene #{n_pg} fila(s) que no coinciden con usos.log (#{usos_archivo.size}); no reimporto para no duplicar")
return 1
end
# Todo o nada: una carga parcial dejaría la cuenta desigual y migrar ya no podría reintentarse (no reimporta)
E.sincronizado do
E.con.exec('BEGIN')
begin
usos_archivo.each { |u| E.usos_registrar_pg(normalizar_uso(u)) }
E.con.exec('COMMIT')
rescue StandardError
E.con.exec('ROLLBACK')
raise
end
end
salida.puts(" → usos: #{usos_archivo.size} fila(s)")
end
verificar(salida)
end
def verificar(salida)
dif = diferencias
dif.each { |clave, distinta| salida.puts(" #{distinta ? '≠' : '='} #{clave}") }
if dif.values.any?
salida.puts("❌ pg difiere de los archivos en: #{dif.select { |_, d| d }.keys.join(', ')}")
1
else
salida.puts("✅ pg coincide con los archivos (#{E::ARCHIVOS.size} claves, #{contar_usos_pg} usos)")
0
end
end
def exportar(salida)
salida.puts("🗄 respaldo de lo que había en disco: #{respaldar}")
E::ARCHIVOS.each_key do |clave|
fila = E.sincronizado { E.con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first }
next salida.puts(" · #{clave}: no está en pg, el archivo queda como estaba") unless fila
E.archivo_guardar(E.ruta(clave), JSON.parse(fila['valor']))
salida.puts(" ← #{clave}")
end
usos = E.sincronizado { E.con.exec('SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos ORDER BY id').to_a }
File.open("#{E::USOS_LOG}.tmp", 'w', 0o600) do |f|
usos.each { |u| f.puts(E.normalizar_uso(u).to_json) }
end
File.rename("#{E::USOS_LOG}.tmp", E::USOS_LOG)
salida.puts(" ← usos: #{usos.size} fila(s)")
verificar(salida)
end
# { clave => true si pg difiere del archivo, ..., 'usos' => true si la cantidad difiere }
def diferencias
d = E::ARCHIVOS.keys.to_h do |clave|
[clave, E.pg_leer(clave, nil) != E.archivo_leer(E.ruta(clave), E::DEFECTOS[clave])]
end
d.merge('usos' => contar_usos_pg != usos_archivo.size)
end
# Líneas viejas de usos.log (anteriores a P204/Fase 3) no traen 'evento': eran todas dispensas (contrato de
# Nexxa::Usos). Sin esto la columna NOT NULL frenó la primera activación real (2026-10-05 02:43).
def normalizar_uso(u)
u.merge('evento' => u['evento'] || 'dispensada', 'individuo' => u['individuo'], 'en' => u['en'] || Time.at(0).iso8601)
end
def contar_usos_pg
E.sincronizado { E.con.exec('SELECT count(*) AS n FROM usos').first['n'].to_i }
end
def usos_archivo
@usos_archivo ||= begin
return [] unless File.exist?(E::USOS_LOG)
File.readlines(E::USOS_LOG).filter_map do |l|
JSON.parse(l)
rescue JSON::ParserError
nil
end
end
end
def respaldar
archivos = (E::ARCHIVOS.values + ['usos.log']).select { |a| File.exist?(File.join(E::DIR, a)) }
tgz = File.join(E::DIR, "bkp_estado_#{Time.now.strftime('%Y%m%d%H%M%S')}.tgz")
system('tar', 'czf', tgz, '-C', E::DIR, *archivos, exception: true) unless archivos.empty?
File.chmod(0o600, tgz) if File.exist?(tgz)
archivos.empty? ? 'sin archivos que respaldar' : tgz
end
end
end
exit Nexxa::CliEstado.call(ARGV.first) if $PROGRAM_NAME == __FILE__
@@ -1,38 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_registrar.rb — Alta de una key con su valor real (D045 §10/§11, P201/Fase2-3)
# Uso: ruby cli_registrar.rb <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,
por: 'cli' # queda en el registro de usos (P337/Fase 1)
)
puts "Registrado: #{provider} → #{identificador} (cuenta: #{cuenta_origen})"
-20
View File
@@ -1,20 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# latido.rb — Heartbeat mínimo, mantiene vivo el proceso del servicio
# ==============================================================================
# NEXXA-F1 (P200) responde a consultas puntuales vía apids chat (SSH bajo
# demanda, sin loop de decisión propio — D045 §1/§4). Este latido NO procesa
# estímulos ni carrera de era (a diferencia de RUBBY/PEGGY) — su único rol es
# marcar 'el organismo está vivo' para el criterio de vida (revive tras
# reinicio de la LXC) y dejar un heartbeat auditable en log, cadencia 300s
# (ME-435: latido ≠ conversar, nunca comparte proceso con el canal directo).
# ==============================================================================
LOG_FILE = File.expand_path('latido.log', __dir__)
CADENCIA_SEGUNDOS = 300
loop do
File.open(LOG_FILE, 'a') { |f| f.puts("#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} — vivo") }
sleep CADENCIA_SEGUNDOS
end
-201
View File
@@ -1,201 +0,0 @@
# frozen_string_literal: true
# lib_auth.rb — Usuarios y sesiones del panel web de NEXXA (P201/Fase4)
# ==============================================================================
# Reemplaza el diseño original (nginx Basic Auth + credencial en candados de
# GEMMA) por corrección explícita del Operador: NEXXA resuelve su propia auth,
# sin dependencia de GEMMA — mismo espíritu de independencia que ya tienen
# lib_tokens.rb (individuos F1) y lib_cripto.rb (master key propia).
#
# Multi-usuario con perfil (corrección 2026-08-03 — el diseño original de un
# solo Operador binario no alcanzaba, el Operador pidió CRUD de usuarios real,
# gateado por perfil): dos perfiles, sin inventar granularidad no pedida —
# - 'admin' → todo, incluida la gestión de usuarios (crear/editar/borrar)
# - 'operador' → todo lo demás (keys, consumidores), sin gestión de usuarios
#
# No reinventa primitivas de seguridad (pedido explícito del Operador): usa
# exactamente el mismo algoritmo ya probado en producción en
# gemma/tools/candados/core/lib_cripto.rb (Armonía Integral) — PBKDF2-HMAC-SHA256,
# 100k iteraciones, salt random — en vez de SHA256 plano (adecuado para el
# token aleatorio de lib_tokens.rb, pero no para una password humana).
#
# Sesión: token aleatorio de alta entropía (mismo patrón que Tokens.generar),
# guardado server-side con expiración, entregado como cookie. HttpOnly/Secure/
# SameSite se arman a mano en el header Set-Cookie (server.rb) porque el
# WEBrick::Cookie de esta versión de Ruby no expone esos atributos — ver
# comentario en server.rb.
# ==============================================================================
require 'json'
require 'securerandom'
require 'openssl'
require 'base64'
require 'time'
require_relative 'lib_estado'
module Nexxa
module Auth
USERS_FILE = Estado.ruta('usuarios')
SESSIONS_FILE = Estado.ruta('sesiones')
PBKDF2_ITER = 100_000
SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable
PERFILES_VALIDOS = %w[admin operador].freeze
# ---------- Usuarios ----------
# Estado vía Nexxa::Estado (P335/Fase 17)
def self.leer_usuarios
Estado.leer('usuarios', USERS_FILE, [])
end
def self.guardar_usuarios(lista)
Estado.guardar('usuarios', USERS_FILE, lista)
end
def self.derivar(password, salt)
OpenSSL::PKCS5.pbkdf2_hmac(password, salt, PBKDF2_ITER, 32, 'SHA256')
end
# Crea un usuario nuevo — devuelve la password EN CLARO solo si el
# caller la generó (bootstrap por cli_admin.rb), o la recibe ya elegida
# (alta vía panel por un admin). Nunca se persiste ni se loguea en claro.
# raise si el usuario ya existe o el perfil no es válido.
def self.crear_usuario(usuario:, password:, perfil:)
usuario = usuario.to_s.strip
raise 'Usuario vacío' if usuario.empty?
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario }
salt = SecureRandom.random_bytes(16)
hash = derivar(password, salt)
lista << {
'usuario' => usuario,
'perfil' => perfil,
'salt' => Base64.strict_encode64(salt),
'hash' => Base64.strict_encode64(hash),
'activo' => true,
'creado' => Time.now.iso8601
}
lista
end
usuario
end
# Verifica usuario+password — devuelve el registro (sin salt/hash) si es
# válido y está activo, nil si no. Comparación de tiempo constante.
def self.autenticar(usuario:, password:)
entrada = leer_usuarios.find { |u| u['usuario'] == usuario.to_s.strip && u['activo'] != false }
return nil unless entrada
salt = Base64.strict_decode64(entrada['salt'])
hash_guardado = Base64.strict_decode64(entrada['hash'])
hash_calculado = derivar(password.to_s, salt)
return nil unless hash_guardado.bytesize == hash_calculado.bytesize &&
OpenSSL.fixed_length_secure_compare(hash_guardado, hash_calculado)
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Todos los usuarios, solo metadata — NUNCA salt/hash (Regla 15).
def self.listar
leer_usuarios.map { |u| u.reject { |k, _| %w[salt hash].include?(k) } }
end
def self.existe?(usuario)
leer_usuarios.any? { |u| u['usuario'] == usuario.to_s.strip }
end
# Edita perfil/activo de un usuario existente. password_nueva opcional
# (rotación). raise si no existe o el perfil no es válido.
def self.actualizar(usuario:, perfil: nil, activo: nil, password_nueva: nil)
entrada = nil
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip }
raise "Usuario '#{usuario}' no encontrado" unless entrada
if perfil
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
entrada['perfil'] = perfil
end
entrada['activo'] = activo unless activo.nil?
if password_nueva && !password_nueva.to_s.strip.empty?
salt = SecureRandom.random_bytes(16)
entrada['salt'] = Base64.strict_encode64(salt)
entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt))
end
lista
end
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Elimina un usuario — destructivo. El caller (server.rb) es responsable
# de impedir que el último admin se borre a sí mismo (guardia de negocio,
# no de esta capa de datos).
def self.eliminar(usuario)
existia = nil
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip }
lista
end
!existia.nil?
end
def self.admins_activos
leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false }
end
# ---------- Sesiones ----------
def self.leer_sesiones
Estado.leer('sesiones', SESSIONS_FILE, {})
end
def self.guardar_sesiones(sesiones)
Estado.guardar('sesiones', SESSIONS_FILE, sesiones)
end
def self.crear_sesion(usuario, perfil)
token = SecureRandom.hex(32)
Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones|
sesiones[token] = {
'usuario' => usuario,
'perfil' => perfil,
'expira' => (Time.now + SESSION_TTL).iso8601
}
sesiones
end
token
end
# Devuelve {usuario, perfil} de la sesión si es válida, nil si no.
def self.sesion(token)
return nil if token.to_s.strip.empty?
entrada = leer_sesiones[token]
return nil unless entrada
# Vencida: se borra con la escritura atómica de cerrar_sesion (la lectura de cada pedido web no toma bloqueo)
if Time.parse(entrada['expira']) < Time.now
cerrar_sesion(token)
return nil
end
{ 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] }
end
def self.sesion_valida?(token)
!sesion(token).nil?
end
def self.cerrar_sesion(token)
existia = nil
Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones|
existia = sesiones.delete(token)
sesiones
end
!existia.nil?
end
end
end
-56
View File
@@ -1,56 +0,0 @@
# frozen_string_literal: true
# lib_checkins.rb — Reporte proactivo de estado de individuos F1 (P216)
# ==============================================================================
# Complementa lib_tokens.rb (identidad) con un registro simple de "qué contó cada
# individuo de sí mismo la última vez" — mismo espíritu que Registro.disponible
# para keys: NEXXA solo guarda lo que le reportan, nunca sale a diagnosticar
# nada por su cuenta. Quien consulta (GEMMA, vía bandeja.rb) decide qué hacer
# con la antigüedad del último reporte.
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_estado'
module Nexxa
module Checkins
STATE_FILE = Estado.ruta('checkins')
# Estado vía Nexxa::Estado (P335/Fase 17)
def self.leer
Estado.leer('checkins', STATE_FILE, {})
end
def self.guardar(state)
Estado.guardar('checkins', STATE_FILE, state)
end
def self.mutar(&)
Estado.mutar('checkins', STATE_FILE, {}, &)
end
# El individuo llega autenticado (individuo_autenticado(req) en server.rb,
# vía Nexxa::Tokens.verificar) — nunca confiar en un id que venga en el
# body, el token YA identifica quién reporta.
def self.registrar(individuo, estado:, detalle: nil)
mutar do |state|
state[individuo] = {
'estado' => estado.to_s,
'detalle' => detalle,
'ultimo_reporte' => Time.now.utc.iso8601
}
state
end
state[individuo]
end
def self.estado(individuo)
leer[individuo]
end
def self.listar
leer
end
end
end
-74
View File
@@ -1,74 +0,0 @@
# frozen_string_literal: true
# lib_cripto.rb — Motor criptográfico AES-256-GCM, adaptado de gemma/tools/candados/core/lib_cripto.rb
# ==============================================================================
# NEXXA-F1 (P201/Fase2) — mismo algoritmo que la bóveda de candados de GEMMA
# (Armonía Integral, no reinventar), pero SIN derivación por frase humana: NEXXA
# cifra/descifra 24/7 sin intervención (D045 §10, storage propio de la key real).
# La master key vive en un archivo local (MasterKey.cargar!), nunca en argv/log.
# ==============================================================================
require 'openssl'
require 'base64'
require 'json'
require 'securerandom'
module Nexxa
class Cripto
ALGORITHM = 'aes-256-gcm'
def initialize(key_bytes)
raise 'Master key debe tener 32 bytes (256 bits)' unless key_bytes.bytesize == 32
@key = key_bytes
end
def encrypt(plaintext)
cipher = OpenSSL::Cipher.new(ALGORITHM)
cipher.encrypt
cipher.key = @key
iv = cipher.random_iv
ciphertext = cipher.update(plaintext.to_s) + cipher.final
payload = { iv: b64(iv), tag: b64(cipher.auth_tag), data: b64(ciphertext) }
Base64.strict_encode64(payload.to_json)
end
def decrypt(token)
p = JSON.parse(Base64.strict_decode64(token), symbolize_names: true)
cipher = OpenSSL::Cipher.new(ALGORITHM)
cipher.decrypt
cipher.key = @key
cipher.iv = db64(p[:iv])
cipher.auth_tag = db64(p[:tag])
cipher.update(db64(p[:data])) + cipher.final
rescue StandardError => e
raise "Error al descifrar: #{e.message}"
end
private
def b64(d) = Base64.strict_encode64(d)
def db64(d) = Base64.strict_decode64(d)
end
module MasterKey
RUTA = File.expand_path('.master_key', __dir__)
# Genera la master key UNA VEZ (idempotente — si ya existe, no la toca).
# Devuelve los bytes en ambos casos. El caller decide si hace backup (candados).
def self.generar_si_falta!
return File.binread(RUTA) if File.exist?(RUTA)
bytes = SecureRandom.random_bytes(32)
File.binwrite(RUTA, bytes)
File.chmod(0o600, RUTA)
bytes
end
def self.cargar!
raise "Master key no existe en #{RUTA} — correr MasterKey.generar_si_falta! primero" unless File.exist?(RUTA)
File.binread(RUTA)
end
end
end
-38
View File
@@ -1,38 +0,0 @@
# frozen_string_literal: true
# lib_envelope.rb — Cifrado de punta a punta hacia el consumidor (P204, "Aplica
# Pilares" sobre la decisión previa de diferirlo)
# ==============================================================================
# Distinto de lib_cripto.rb (AES simétrico, master key propia de NEXXA, cifra EN
# REPOSO — lo que NEXXA guarda). Esto es asimétrico (RSA-OAEP), cifra PARA EL
# CONSUMIDOR — ni NEXXA ni nadie que capture el cuerpo de la respuesta HTTP
# puede leer el valor sin la clave PRIVADA del individuo, que NUNCA sale de
# ese individuo (NEXXA solo guarda la pública, ver lib_tokens.rb).
#
# RSA-OAEP directo (sin AES intermedio): las API keys son strings cortos
# (~30-60 bytes) — un RSA de 2048 bits con padding OAEP-SHA256 cifra hasta
# ~190 bytes de una, de sobra. No hace falta el patrón "envelope" clásico
# (RSA cifra una clave AES efímera, AES cifra el payload grande) porque acá
# el payload YA es chico — agregar esa capa sería complejidad sin beneficio
# real (Menos es Más).
# ==============================================================================
require 'openssl'
require 'base64'
module Nexxa
module Envelope
# Cifra `valor` con la clave pública PEM del consumidor — devuelve base64,
# listo para meter en un campo JSON de la respuesta HTTP. Nunca falla en
# silencio: una clave pública inválida hace que esto reviente (server.rb
# decide qué hacer, no lo traga acá).
def self.cifrar_para(clave_publica_pem, valor)
rsa = OpenSSL::PKey::RSA.new(clave_publica_pem)
Base64.strict_encode64(rsa.public_encrypt(valor.to_s, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING))
end
# Deliberadamente NO hay Envelope.descifrar acá — descifrar es trabajo
# del CONSUMIDOR con su propia clave privada, nunca de NEXXA. Si NEXXA
# pudiera descifrar esto, no sería de punta a punta.
end
end
-223
View File
@@ -1,223 +0,0 @@
# frozen_string_literal: true
# lib_estado.rb — Único punto de acceso al estado de NEXXA (P335/Fase 17, REG002 R15)
# ==============================================================================
# registro, tokens, pools, checkins, usuarios y sesiones (blobs JSON) y el log de usos pasan por acá. Dos motores:
# archivo — el de siempre: un JSON 0600 junto al código por clave (escritura atómica tmp+rename) y usos.log JSONL.
# pg — Postgres PROPIO de srvv-nexxa (decisión del Operador 2026-10-05: NEXXA sigue en pie aunque srv-ns8
# caiga). Tablas estado (clave, valor jsonb) y usos. Socket local con autenticación peer: el usuario del
# servicio es el rol, sin contraseña que guardar.
# El motor se elige EXPLÍCITO con NEXXA_ESTADO=pg (drop-in systemd de los dos servicios); sin la variable, archivo.
# Nunca cae solo de pg a archivo: nexxa-http y nexxa con motores distintos partirían el estado en dos.
#
# mutar(clave) { |v| ...; v } es leer-modificar-guardar ATÓMICO: SELECT ... FOR UPDATE en una transacción (pg) o
# flock exclusivo (archivo). Antes los dos servicios leían, modificaban y guardaban el mismo archivo sin bloqueo.
# ==============================================================================
require 'json'
require 'monitor'
require 'time'
module Nexxa
module Estado
MOTORES = %w[archivo pg].freeze
DIR = __dir__
USOS_LOG = File.join(__dir__, 'usos.log').freeze
MONITOR = Monitor.new
# Fuente única clave → archivo del motor archivo (los libs toman su STATE_FILE de acá y cli_estado recorre esto)
ARCHIVOS = {
'registro' => 'registro.json', 'tokens' => 'tokens.json', 'pools' => 'pools.json',
'checkins' => 'checkins.json', 'usuarios' => '.usuarios.json', 'sesiones' => '.sessions.json'
}.freeze
DEFECTOS = {
'registro' => { 'keys' => [] }, 'tokens' => { 'tokens' => [] }, 'pools' => { 'individuos' => {} },
'checkins' => {}, 'usuarios' => [], 'sesiones' => {}
}.freeze
module_function
def motor
m = ENV.fetch('NEXXA_ESTADO', 'archivo')
raise ArgumentError, "NEXXA_ESTADO=#{m} inválido (#{MOTORES.join('|')})" unless MOTORES.include?(m)
m
end
def pg?
motor == 'pg'
end
def ruta(clave)
File.join(DIR, ARCHIVOS.fetch(clave))
end
# archivo: ruta del JSON de esa clave (el mismo nombre que tenía antes de esta capa)
def leer(clave, archivo, defecto)
pg? ? pg_leer(clave, defecto) : archivo_leer(archivo, defecto)
end
def guardar(clave, archivo, valor)
pg? ? pg_guardar(clave, valor) : archivo_guardar(archivo, valor)
valor
end
def mutar(clave, archivo, defecto)
if pg?
# BEGIN/COMMIT a mano con ensure: un error o un 'return' dentro del bloque (salida no local) hacen ROLLBACK y
# nunca dejan la conexión a mitad de una transacción. Igual que el motor archivo: sin salida normal no se guarda.
# Los bloques no usan 'return'.
sincronizado do
con.exec('BEGIN')
begin
con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ON CONFLICT (clave) DO NOTHING',
[clave, JSON.generate(defecto)])
fila = con.exec_params('SELECT valor FROM estado WHERE clave = $1 FOR UPDATE', [clave]).first
nuevo = yield(JSON.parse(fila['valor']))
con.exec_params('UPDATE estado SET valor = $2::jsonb, actualizado_en = NOW() WHERE clave = $1', [clave, JSON.generate(nuevo)])
nuevo
rescue Exception # rubocop:disable Lint/RescueException -- todo error deshace y se re-lanza
con.exec('ROLLBACK')
raise
else
con.exec('COMMIT')
nuevo
ensure
con.exec('ROLLBACK') unless con.transaction_status.zero? # 0 = PQTRANS_IDLE
end
end
else
File.open("#{archivo}.lock", File::RDWR | File::CREAT, 0o600) do |l|
l.flock(File::LOCK_EX)
nuevo = yield(archivo_leer(archivo, defecto))
archivo_guardar(archivo, nuevo)
nuevo
end
end
end
# ---------- usos (append-only) ----------
def usos_registrar(linea)
pg? ? usos_registrar_pg(linea) : File.open(USOS_LOG, 'a') { |f| f.puts(linea.to_json) }
end
def usos_registrar_pg(linea)
sincronizado do
con.exec_params('INSERT INTO usos (provider, identificador, individuo, evento, en, motivo, hasta) ' \
'VALUES ($1, $2, $3, $4, $5, $6, $7)',
linea.values_at('provider', 'identificador', 'individuo', 'evento', 'en', 'motivo', 'hasta'))
end
end
FILTROS_USOS = %w[provider identificador individuo evento].freeze
# Más reciente primero. Filtros exactos por campo y 'desde' (Time) para una ventana (P337/Fase 1)
def usos_historial(provider: nil, identificador: nil, individuo: nil, evento: nil, desde: nil, limit: 100)
f = { 'provider' => provider, 'identificador' => identificador, 'individuo' => individuo, 'evento' => evento }
return usos_archivo(f, desde, limit) unless pg?
sincronizado do
con.exec_params(<<~SQL, f.values_at(*FILTROS_USOS) + [desde&.iso8601, limit]).map { |u| normalizar_uso(u) }
SELECT provider, identificador, individuo, evento, en, motivo, hasta FROM usos
WHERE ($1::text IS NULL OR provider = $1) AND ($2::text IS NULL OR identificador = $2)
AND ($3::text IS NULL OR individuo = $3) AND ($4::text IS NULL OR evento = $4)
AND ($5::timestamptz IS NULL OR en >= $5)
ORDER BY id DESC LIMIT $6
SQL
end
end
# Fechas en ISO 8601 con zona, igual en los dos motores
def normalizar_uso(u)
u.merge('en' => Time.parse(u['en'].to_s).iso8601, 'hasta' => u['hasta'] && Time.parse(u['hasta'].to_s).iso8601(3),
'motivo' => u['motivo'])
end
# ---------- motor archivo ----------
def archivo_leer(archivo, defecto)
return defecto unless File.exist?(archivo)
JSON.parse(File.read(archivo, encoding: 'UTF-8'))
rescue JSON::ParserError
defecto
end
def archivo_guardar(archivo, valor)
tmp = "#{archivo}.tmp-#{Process.pid}-#{Thread.current.object_id}"
File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(valor) + "\n") }
File.rename(tmp, archivo)
end
def usos_archivo(filtros, desde, limit)
return [] unless File.exist?(USOS_LOG)
lineas = File.readlines(USOS_LOG, encoding: 'UTF-8').filter_map do |l| # locale C del servicio (ME-1216)
JSON.parse(l)
rescue JSON::ParserError
nil
end
filtros.each { |campo, valor| lineas.select! { |l| l[campo] == valor } if valor }
lineas.select! { |l| l['en'] && Time.parse(l['en']) >= desde } if desde
lineas.last(limit).reverse.map { |u| normalizar_uso(u) }
end
# ---------- motor pg ----------
def pg_leer(clave, defecto)
fila = sincronizado { con.exec_params('SELECT valor FROM estado WHERE clave = $1', [clave]).first }
fila ? JSON.parse(fila['valor']) : defecto
end
def pg_guardar(clave, valor)
sincronizado do
con.exec_params('INSERT INTO estado (clave, valor) VALUES ($1, $2::jsonb) ' \
'ON CONFLICT (clave) DO UPDATE SET valor = EXCLUDED.valor, actualizado_en = NOW()',
[clave, JSON.generate(valor)])
end
end
ESQUEMA = <<~SQL
CREATE TABLE IF NOT EXISTS estado (
clave TEXT PRIMARY KEY,
valor JSONB NOT NULL,
actualizado_en TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS usos (
id BIGSERIAL PRIMARY KEY,
provider TEXT NOT NULL,
identificador TEXT NOT NULL,
individuo TEXT,
evento TEXT NOT NULL,
en TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS usos_key ON usos (provider, identificador);
ALTER TABLE usos ADD COLUMN IF NOT EXISTS motivo TEXT;
ALTER TABLE usos ADD COLUMN IF NOT EXISTS hasta TIMESTAMPTZ;
CREATE INDEX IF NOT EXISTS usos_en ON usos (en);
SQL
def crear_esquema!
sincronizado { con.exec(ESQUEMA) }
end
# Conexión única por proceso (inyectable en tests). Monitor reentrante: WEBrick atiende en varios hilos y un bloque
# de mutar puede llamar a otra operación de Estado.
def con
@con ||= begin
require 'pg'
c = PG.connect(dbname: ENV.fetch('NEXXA_PG_DB', 'nexxa'))
c.exec(ESQUEMA) # idempotente: un despliegue que amplía el esquema se aplica solo al arrancar (P337/Fase 1)
c
end
end
def con=(otra)
@con = otra
end
def sincronizado(&)
MONITOR.synchronize(&)
end
end
end
-220
View File
@@ -1,220 +0,0 @@
# frozen_string_literal: true
# lib_pools.rb — Pools de keys POR INDIVIDUO: mente y red de seguridad (P335/Fase 4, Operador 2026-10-04)
#
# Cada individuo tiene dos pools: MENTE (las keys con las que piensa y opera) y RED (solo para el aviso de batería
# baja). Un pool MEZCLA proveedores y una key puede estar en varios pools (exclusiva o compartida). Es el TERCER eje de
# una key (ME-609): `cuenta_origen` dice quién la aportó (permanente, informativo), `reservado_por` quién la tiene AHORA
# (efímero) y la asignación a pools es CONFIGURACIÓN permanente que decide un admin desde nexxa-web.
#
# Persistencia: pools.json junto a registro.json (0600). NEXXA guarda todo su estado en JSON en su hábitat y no tiene
# Postgres (REG002 R15 lo pide justificar: un individuo sin BD propia; migrarlo a BD es otra decisión). Separado de
# registro.json a propósito: lo que se edita a mano desde la web (config) no se mezcla con el estado vivo de cada key.
#
# Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json).
require 'json'
require_relative 'lib_estado'
module Nexxa
module Pools
STATE_FILE = Estado.ruta('pools')
ROLES = %w[mente red].freeze
module_function
# Estado vía Nexxa::Estado (P335/Fase 17)
def leer
d = Estado.leer('pools', STATE_FILE, { 'individuos' => {} })
d['individuos'] ||= {}
d
end
def guardar(state)
Estado.guardar('pools', STATE_FILE, state)
end
def mutar
Estado.mutar('pools', STATE_FILE, { 'individuos' => {} }) do |d|
d['individuos'] ||= {}
yield d
end
end
def ref(provider, identificador)
"#{provider}/#{identificador}"
end
# Refs del pool de un individuo para un rol. => ["gemini/abby", "deepseek/deepseek-01", ...]
def refs(individuo, rol)
Array(leer.dig('individuos', individuo.to_s, rol.to_s))
end
# Asigna una key al pool. Idempotente. Valida rol y que la key exista en el registro (inyectable para tests).
def asignar(individuo:, rol:, provider:, identificador:, existe: nil)
validar!(individuo, rol)
existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } }
raise "Key no encontrada: #{ref(provider, identificador)}" unless existe.call(provider, identificador)
pool = nil
mutar do |state|
pool = (state['individuos'][individuo] ||= {})[rol] ||= []
r = ref(provider, identificador)
pool << r unless pool.include?(r)
state
end
pool
end
# Quita una key de un pool. => true si estaba.
def quitar(individuo:, rol:, provider:, identificador:)
validar!(individuo, rol)
quitado = nil
mutar do |state|
pool = state.dig('individuos', individuo, rol)
quitado = pool&.delete(ref(provider, identificador))
if quitado
state['individuos'][individuo].delete(rol) if pool.empty?
state['individuos'].delete(individuo) if state['individuos'][individuo].empty?
end
state
end
!quitado.nil?
end
# Deja el pool EXACTAMENTE con estas refs (editar desde nexxa-web, P335/Fase 12). Valida todas antes de escribir:
# una sola inválida y no se toca nada. Lista vacía = vaciar el pool. => refs finales
def reemplazar(individuo:, rol:, refs:, existe: nil)
validar!(individuo, rol)
existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } }
refs = Array(refs).map(&:to_s).uniq
malas = refs.reject { |r| (p, i = r.split('/', 2)) && i && existe.call(p, i) }
raise "Key(s) no encontrada(s): #{malas.join(', ')}" unless malas.empty?
mutar do |state|
roles = (state['individuos'][individuo] ||= {})
refs.empty? ? roles.delete(rol) : roles[rol] = refs
state['individuos'].delete(individuo) if roles.empty?
state
end
refs
end
# Pasa una key del rol 'de' al otro rol del mismo individuo, en una sola escritura. => rol destino
def mover(individuo:, de:, provider:, identificador:)
validar!(individuo, de)
a = (ROLES - [de.to_s]).first
r = ref(provider, identificador)
mutar do |state|
roles = state.dig('individuos', individuo)
raise "#{r} no está en #{individuo}/#{de}" unless roles && Array(roles[de]).include?(r)
roles[de].delete(r)
roles.delete(de) if roles[de].empty?
(roles[a] ||= []) << r unless Array(roles[a]).include?(r)
state
end
a
end
# Al renombrar una key, sus refs en todos los pools pasan al nombre nuevo (P335/Fase 13)
def renombrar_key(provider:, de:, a:)
cambio = nil
mutar do |state|
viejo = ref(provider, de)
nuevo = ref(provider, a)
cambio = false
state['individuos'].each_value do |roles|
roles.each_value { |pool| (i = pool.index(viejo)) && (pool[i] = nuevo) && (cambio = true) }
end
state
end
cambio
end
# Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas).
def olvidar_key(provider:, identificador:)
cambio = nil
mutar do |state|
r = ref(provider, identificador)
cambio = false
state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } }
state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } }
state['individuos'].delete_if { |_, roles| roles.empty? }
state
end
cambio
end
# Al revocar un individuo (sin token ya no puede pedir) sus pools se borran: sin referencias colgadas (P335/F12)
def olvidar_individuo(individuo)
borrado = nil
mutar do |state|
borrado = state['individuos'].delete(individuo.to_s)
state
end
!borrado.nil?
end
# Resumen por rol para la sección Individuos y el Dashboard: { 'mente' => {'total'=>, 'disponibles'=>}, ... }
def resumen(individuo)
ROLES.to_h do |rol|
filas = Nexxa::Registro.estado_en(refs(individuo, rol))
[rol, { 'total' => filas.size, 'disponibles' => filas.count { |f| f['estado'] == 'disponible' } }]
end
end
# Pools en los que está una key. => [{ 'individuo' =>, 'rol' => }]
def de_key(provider, identificador, state = leer)
r = ref(provider, identificador)
state['individuos'].flat_map do |ind, roles|
roles.select { |_, pool| pool.include?(r) }.map { |rol, _| { 'individuo' => ind, 'rol' => rol } }
end
end
# --- Selección por NOMBRE (P335/Fase 5): el único lugar que decide si /disponible/<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
# Elegir y reservar la key en UN paso atómico (P335/Fase 17): mismo criterio de candidatas que disponible.
# => entrada reservada, entrada solo-metadata sin reservar (sin valor_cifrado) o nil si no hay libre.
def dispensar(individuo, nombre)
if rol?(nombre)
Nexxa::Registro.reservar_libre(individuo: individuo, refs: refs(individuo, nombre))
else
Nexxa::Registro.reservar_libre(individuo: individuo, provider: nombre)
end
end
def proxima(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre)
end
def estado(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.estado_en(refs(individuo, nombre)) : Nexxa::Registro.estado_pool(nombre)
end
# Pools completos con el estado de cada key, para nexxa-web. Nunca valores.
def con_estado
leer['individuos'].transform_values do |roles|
roles.to_h { |rol, pool| [rol, Nexxa::Registro.estado_en(pool)] }
end
end
def validar!(individuo, rol)
raise 'Falta el individuo' if individuo.to_s.strip.empty?
raise "rol inválido: #{rol} (esperado: #{ROLES.join('|')})" unless ROLES.include?(rol.to_s)
end
end
end
-452
View File
@@ -1,452 +0,0 @@
# frozen_string_literal: true
# lib_registro.rb — Fuente de verdad de cuotas Y del valor real de cada key
# ==============================================================================
# NEXXA-F1 (P200, evolucionado en P201/Fase2-3 — D045 §10/§11) — registro propio,
# inspirado en apirot.rb (P121, dtic-GEMMA) pero con delta de dominio: campo
# 'provider'/'cuenta_origen' (D045 §2.3/§11) y, desde P201/Fase2, el VALOR REAL
# cifrado de cada key (D045 §10: NEXXA es la fuente de verdad, ya no candados,
# para API keys de terceros). 'identificador' es una ETIQUETA legible (ej.
# 'gemini-01'), no el secreto — el secreto vive solo en 'valor_cifrado', nunca
# en texto plano en disco ni en ningún log (ME-293/296).
#
# Dos ejes distintos, no confundir (corrección P201/Fase3, D045 §11):
# - cuenta_origen: PERMANENTE — qué cuenta ante el proveedor generó esta key.
# Informativo, nunca filtro de acceso (pool compartido, D045 §8).
# - ultimo_individuo / reservar / reportar / lib_usos.rb: EFÍMERO — qué individuo
# del ecosistema APIDs la tiene asignada ahora (o la tuvo la última vez). Una
# key se reclama y se libera — no tiene "dueño" en ese sentido.
# ==============================================================================
# NO hace: no llama a los providers externos, no valida las keys en sí — solo
# lleva el registro declarado (alta vía mini-app o cli_registrar.rb)
# ==============================================================================
# Salud real de keys (P204/Fase3, D045 §8) — el CONSUMIDOR es el árbitro del
# agotamiento, no NEXXA: solo él le pegó al proveedor real. reservar() aplica
# una reserva corta de contención al dispensar (evita doble-asignación
# concurrente, sin asumir agotamiento); reportar() recibe la señal real
# ('sana' renueva, 'liberada' suelta, 'agotada' recién ahí bloquea con
# disponible_desde). Ver registro.json: campos reservado_por/reservado_hasta.
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_cripto'
require_relative 'lib_usos'
require_relative 'lib_estado'
module Nexxa
module Registro
STATE_FILE = Estado.ruta('registro')
# Reserva corta de contención (P204/Fase3, D045 §8) — no asume agotamiento,
# solo evita que 2 consumidores reciban la misma key mientras uno la está
# probando. Vence sola (evaluada en self.disponible, sin proceso de limpieza
# aparte) si nadie reporta nada; self.reportar la renueva o la libera.
RESERVA_TTL_SEGUNDOS = 600
# Estado vía Nexxa::Estado (P335/Fase 17): archivo o Postgres según NEXXA_ESTADO
def self.leer
Estado.leer('registro', STATE_FILE, { 'keys' => [] })
end
def self.guardar(state)
Estado.guardar('registro', STATE_FILE, state)
end
# Leer-modificar-guardar atómico (nexxa-http y nexxa comparten el registro)
def self.mutar(&)
Estado.mutar('registro', STATE_FILE, { 'keys' => [] }, &)
end
# provider: "gemini"/"groq"/... ; identificador: ETIQUETA legible (ej. "gemini-01"),
# nunca el secreto ; cuenta_origen: cuenta ante el proveedor que generó la key —
# PERMANENTE, informativo, no filtro de acceso (D045 §8/§11) ; reset_segundos:
# ciclo de cuota del proveedor, se persiste para que marcar_uso pueda recalcular
# disponible_desde sin que el caller tenga que volver a pasarlo ; valor: el
# secreto en texto plano — se cifra acá mismo, nunca se persiste sin cifrar
# (nil = alta solo de metadata, compatibilidad con registros viejos aún no
# migrados, D045 §9→§10). ultimo_uso: nil (default) = key nueva/sin agotar,
# disponible YA — nunca se asume 'se usó ahora' (bug real encontrado en
# P200/Fase4: registrar una key recién creada la dejaba "agotada" 24h por
# error, ME-603). Pasar ultimo_uso explícito solo cuando se sabe que la key
# SÍ se agotó en ese momento.
# por (P337/Fase 1): quién la dio de alta o la reemplazó, para el registro ('web:<usuario>', 'cli'...)
def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil, por: nil)
ahora = Time.now
evento = nil
disponible_desde = ultimo_uso ? (Time.parse(ultimo_uso) + reset_segundos).iso8601(3) : ahora.iso8601(3)
ultimo_uso ||= ahora.iso8601(3)
valor_cifrado = valor ? cifrar(valor) : nil
mutar do |state|
existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
evento = existente ? 'editada' : 'alta'
if existente
existente.merge!(
'ultimo_uso' => ultimo_uso,
'disponible_desde' => disponible_desde,
'cuenta_origen' => cuenta_origen,
'reset_segundos' => reset_segundos
)
existente['valor_cifrado'] = valor_cifrado if valor_cifrado
else
state['keys'] << {
'provider' => provider,
'identificador' => identificador,
'cuenta_origen' => cuenta_origen,
'reset_segundos' => reset_segundos,
'ultimo_uso' => ultimo_uso,
'ultimo_individuo' => nil,
'disponible_desde' => disponible_desde,
'valor_cifrado' => valor_cifrado,
'activo' => true,
'reservado_por' => nil,
'reservado_hasta' => nil
}
end
state
end.tap do
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', en: ahora,
evento: evento, motivo: evento == 'editada' && valor ? 'valor reemplazado' : nil)
end
end
# Edita metadata de una key existente (P201/Fase3) — NUNCA el valor (eso no
# se re-muestra, se reemplaza vía 'registrar' con un valor nuevo si hace
# falta rotarlo). Cada parámetro es opcional: solo se actualiza lo pasado.
def self.actualizar(provider:, identificador:, cuenta_origen: nil, reset_segundos: nil, activo: nil, por: nil)
entrada = nil
cambios = []
mutar do |state|
entrada = buscar!(state, provider, identificador)
{ 'cuenta_origen' => cuenta_origen, 'reset_segundos' => reset_segundos, 'activo' => activo }.each do |campo, valor|
next if valor.nil? || entrada[campo] == valor
cambios << "#{campo}: #{entrada[campo].inspect} → #{valor.inspect}"
entrada[campo] = valor
end
state
end
# Qué cambió, sin ambigüedad (nunca el valor de la key: este método no lo toca)
unless cambios.empty?
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido',
evento: 'editada', motivo: cambios.join('; '))
end
entrada
end
def self.buscar!(state, provider, identificador)
state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador } ||
raise("Key no encontrada: #{provider}/#{identificador}")
end
IDENTIFICADOR_VALIDO = /\A[a-z0-9][a-z0-9._-]{0,63}\z/.freeze
# Cambia el identificador de una key (P335/Fase 13). Único dentro del provider; rechazado mientras esté RESERVADA
# (el consumidor que la tiene reportaría con el nombre viejo). El historial previo de usos queda con el nombre
# anterior (log append-only) y se registra el evento 'renombrada'. Los pools los actualiza el llamador (Pools).
def self.renombrar(provider:, de:, a:, usuario: nil, ahora: Time.now)
a = a.to_s.strip
raise "Identificador inválido: '#{a}' (minúsculas, números, punto, guion o guion bajo)" unless a.match?(IDENTIFICADOR_VALIDO)
return leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == de } if a == de
entrada = nil
mutar do |state|
entrada = buscar!(state, provider, de)
raise "Ya existe #{provider}/#{a}" if state['keys'].any? { |k| k['provider'] == provider && k['identificador'] == a }
if entrada['reservado_hasta'] && Time.parse(entrada['reservado_hasta']) > ahora
raise "#{provider}/#{de} está reservada por #{entrada['reservado_por']}: esperá a que la libere para renombrarla"
end
entrada['identificador'] = a
state
end
Nexxa::Usos.registrar(provider: provider, identificador: a, individuo: usuario ? "web:#{usuario}" : 'web',
en: ahora, evento: 'renombrada', motivo: "antes #{de}")
entrada
end
# Elimina una key del registro — destructivo, sin deshacer (P201/Fase3).
# No borra su historial en lib_usos.rb (log append-only, queda como evidencia).
def self.eliminar(provider:, identificador:, por: nil)
existia = nil
mutar do |state|
existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador }
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: por || 'desconocido', evento: 'baja') if existia
!existia.nil?
end
# Todas las keys con su estado de la taxonomía (P337/Fase 1), calculado sobre la key COMPLETA (sin valor_cifrado
# daría sin_valor) y recién después sin el valor (Regla 15). Lo que muestra nexxa-web: nada se recalcula allá.
def self.todas_con_estado(ahora = Time.now)
leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' }.merge(estado_de_key(k, ahora)) }
end
# Todas las keys, solo metadata — para la vista de consulta de la mini-app
# (P201/Fase3). Nunca incluye valor_cifrado, bajo ningún caso (Regla 15).
def self.todas
leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' } }
end
# Descifra y devuelve el valor real de una key — SOLO para el endpoint HTTP
# autenticado (Fase 2/2.4). El router de apids chat (router.rb) nunca llama
# a esto — sigue devolviendo solo metadata, texto plano sin el secreto.
def self.revelar(provider:, identificador:)
entrada = leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
return nil unless entrada && entrada['valor_cifrado']
descifrar(entrada['valor_cifrado'])
end
# Reserva corta de contención al dispensar (P204/Fase3, D045 §8) — reemplaza
# el bloqueo ciego de la vieja marcar_uso: NO asume agotamiento, solo evita
# que 2 consumidores reciban la misma key mientras uno la está probando.
# disponible_desde queda intacto — el agotamiento real solo lo aplica
# self.reportar(estado: 'agotada'), con la señal del consumidor. Se llama
# automático al dispensar (server.rb, GET /disponible).
def self.reservar(provider:, identificador:, individuo:)
ahora = Time.now
entrada = nil
mutar do |state|
entrada = aplicar_reserva(buscar!(state, provider, identificador), individuo, ahora)
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada',
hasta: entrada['reservado_hasta'])
entrada
end
# Elegir la key libre y reservarla en UN paso atómico (P335/Fase 17). Antes se elegía (leer) y se reservaba después
# (otro leer/guardar): dos consumidores simultáneos podían recibir la misma key. Candidatas: las refs de un pool
# o todas las de un provider. Una key solo-metadata (sin valor_cifrado, D045 §9) se devuelve SIN reservar para que
# el llamador responda sin_valor_migrado como antes. => entrada (con valor_cifrado) o nil si no hay libre.
def self.reservar_libre(individuo:, refs: nil, provider: nil)
ahora = Time.now
elegida = nil
mutar do |state|
candidatas = state['keys'].select do |k|
refs ? Array(refs).include?("#{k['provider']}/#{k['identificador']}") : k['provider'] == provider
end
elegida = elegir_libre(candidatas)
aplicar_reserva(elegida, individuo, ahora) if elegida && elegida['valor_cifrado']
state
end
if elegida && elegida['valor_cifrado']
Nexxa::Usos.registrar(provider: elegida['provider'], identificador: elegida['identificador'], individuo: individuo,
en: ahora, evento: 'dispensada', hasta: elegida['reservado_hasta'])
end
elegida
end
def self.aplicar_reserva(entrada, individuo, ahora)
entrada['ultimo_uso'] = ahora.iso8601(3)
entrada['ultimo_individuo'] = individuo
entrada['reservado_por'] = individuo
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
entrada
end
# Reporte real del consumidor sobre una key que tiene reservada (P204/Fase3,
# D045 §8) — el consumidor es el árbitro de salud, no NEXXA (solo él le pegó
# al proveedor real). Exige reservado_por == individuo — nadie reporta el
# estado de una key que no tiene reservada.
# 'sana' → renueva la reserva (sigue activo, evita que le venza en uso)
# 'liberada' → libera la reserva ya, sin tocar disponible_desde (buen
# ciudadano que terminó antes de tiempo)
# 'agotada' → recién acá se aplica el bloqueo real: disponible_desde =
# ahora + (liberar_en_segundos si el proveedor dio una pista
# real, si no el reset_segundos registrado como fallback)
#
# P334/Fase 4 (GEMMA, 2026-10-04): quien marcó una key 'agotada' puede DESHACER su propio reporte con
# 'liberada' aunque ya no la tenga reservada (agotada_por == individuo y el bloqueo sigue vigente). Caso real
# 2026-10-01 19:46: un 429 por minuto reportado como agotada bloqueó el pool compartido y el consumidor no podía
# revertirlo (409). Solo el autor del reporte: nadie libera lo que bloqueó otro.
def self.reportar(provider:, identificador:, individuo:, estado:, liberar_en_segundos: nil, motivo: nil)
ahora = Time.now
entrada = nil
evento = hasta = nil
mutar do |state| # sin 'return' adentro (P335/Fase 17): el bloque es una transacción
entrada = buscar!(state, provider, identificador)
if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora)
entrada['disponible_desde'] = ahora.iso8601(3)
entrada['agotada_por'] = nil
evento = 'revertida'
else
raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo
evento, hasta = aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo)
end
state
end
# Registro completo (P337/Fase 1): cada reporte queda, con el motivo del proveedor y hasta cuándo
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: evento,
motivo: (motivo.to_s[0, 200] if %w[pausada agotada].include?(evento)), hasta: hasta)
entrada
end
# => [evento de usos, hasta] — renovada (con el nuevo fin de reserva), liberada, pausada o agotada (con el fin del bloqueo)
def self.aplicar_reporte(entrada, estado, individuo, ahora, liberar_en_segundos, motivo)
case estado
when 'sana'
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
['renovada', entrada['reservado_hasta']]
when 'liberada'
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
['liberada', nil]
when 'agotada'
reset_segundos = entrada['reset_segundos']
unless reset_segundos
raise "Key #{entrada['provider']}/#{entrada['identificador']} sin reset_segundos persistido — no se puede reportar agotada"
end
entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3)
entrada['bloqueo'] = tipo_bloqueo(liberar_en_segundos)
entrada['agotada_por'] = individuo
entrada['motivo_agotada'] = motivo.to_s.empty? ? nil : motivo.to_s[0, 200]
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
[entrada['bloqueo'] == 'pausa' ? 'pausada' : 'agotada', entrada['disponible_desde']]
else
raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)"
end
end
# Liberación por un ADMIN desde nexxa-web (P335/Fase 7): la key queda disponible ya, sin reserva ni marca de
# agotada, sea quien sea que la bloqueó. El rastro queda en usos ('liberada-admin', con el usuario de la web).
def self.liberar_admin(provider:, identificador:, usuario:)
ahora = Time.now
entrada = nil
mutar do |state|
entrada = buscar!(state, provider, identificador)
entrada['disponible_desde'] = ahora.iso8601(3) if Time.parse(entrada['disponible_desde']) > ahora
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
entrada['agotada_por'] = nil
entrada['motivo_agotada'] = nil
entrada['bloqueo'] = nil
state
end
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: "web:#{usuario}", en: ahora,
evento: 'liberada-admin')
entrada
end
# ¿individuo puede deshacer el 'agotada' de esta key? Solo si lo reportó él y el bloqueo sigue vigente.
def self.revertible_por?(entrada, individuo, ahora = Time.now)
entrada['agotada_por'] == individuo && Time.parse(entrada['disponible_desde']) > ahora
end
# Estado del pool de un provider, por key, SIN el valor (P334/Fase 4): para diagnosticar desde un consumidor sin
# entrar a la mini-app. estado: inactiva | agotada | reservada | disponible.
def self.estado_pool(provider, ahora = Time.now)
estado_de(leer['keys'].select { |k| k['provider'] == provider }, ahora)
end
# Estado de las keys de un pool (P335/Fase 5): mezcla proveedores, por eso cada fila trae su provider.
def self.estado_en(refs, ahora = Time.now)
estado_de(de_refs(refs), ahora)
end
# Taxonomía CERRADA de estados (P337/Fase 1): la única fuente; nexxa-web y GEMMA la muestran, nunca la recalculan.
# Excluyentes y en este orden de precedencia. Campos uniformes: hasta = cuándo cambia de estado, por = quién
# reservó o bloqueó, motivo = lo que contestó el proveedor.
ESTADOS = %w[disponible en_uso en_pausa agotada desactivada sin_valor].freeze
# Un bloqueo de hasta esto es una PAUSA por límite del proveedor (el 429 por minuto); más largo, cuota agotada
PAUSA_MAX_SEG = 300
def self.estado_de(keys, ahora = Time.now)
keys.map { |k| { 'provider' => k['provider'], 'identificador' => k['identificador'] }.merge(estado_de_key(k, ahora)) }
end
def self.estado_de_key(k, ahora = Time.now)
bloqueada = Time.parse(k['disponible_desde']) > ahora
reservada = k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
e = if k['activo'] == false then { 'estado' => 'desactivada' }
elsif !k.key?('valor_cifrado') || k['valor_cifrado'].nil? then { 'estado' => 'sin_valor' }
elsif bloqueada
{ 'estado' => k['bloqueo'] == 'pausa' ? 'en_pausa' : 'agotada', 'hasta' => k['disponible_desde'],
'por' => k['agotada_por'], 'motivo' => k['motivo_agotada'] }
elsif reservada then { 'estado' => 'en_uso', 'hasta' => k['reservado_hasta'], 'por' => k['reservado_por'] }
else { 'estado' => 'disponible' }
end
{ 'hasta' => nil, 'por' => nil, 'motivo' => nil }.merge(e)
.merge('ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo'])
end
# 'pausa' (bloqueo corto, límite del proveedor) o 'agotada' (cuota del ciclo), decidido por la duración real
def self.tipo_bloqueo(segundos)
segundos && segundos.to_i <= PAUSA_MAX_SEG ? 'pausa' : 'agotada'
end
def self.cifrar(valor)
Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).encrypt(valor)
end
def self.descifrar(valor_cifrado)
Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).decrypt(valor_cifrado)
end
# Devuelve la key elegible MENOS USADA RECIENTEMENTE del provider (rotación
# del pool, P204/Fase4, propuesta del Operador) — nil si ninguna es elegible.
# Antes usaba el primer match del array: si la primera key nunca se agotaba,
# las demás no se usaban jamás y quedaban en riesgo de que el proveedor las
# diera de baja por inactividad. min_by sobre ultimo_uso rota el pool solo,
# sin estado adicional (nil = nunca usada, va primero). Elegible = 'activo'
# ausente/true (compat keys viejas), disponible_desde vencido, y
# reservado_hasta ausente/nil/vencido (compat keys pre-P204/Fase3 — la
# reserva vence sola acá, evaluada al consultar, sin limpieza aparte).
def self.disponible(provider)
elegir_libre(leer['keys'].select { |k| k['provider'] == provider })
end
# Igual que disponible, pero dentro de un POOL (P335/Fase 4): refs "provider/identificador" que pueden mezclar
# proveedores. La menos usada recientemente entre las libres, sin importar el proveedor.
def self.disponible_en(refs)
elegir_libre(de_refs(refs))
end
def self.proxima_en(refs)
proxima_de(de_refs(refs))
end
# Criterio ÚNICO de "cuándo se libera" (P335/Fase 17): la más tardía entre el fin del agotamiento y el fin de la
# reserva. Antes solo miraba disponible_desde y, con todas las keys reservadas, anunciaba una hora ya pasada
# (caso real 2026-10-05 02:39: "la próxima se libera 2026-10-04T11:25"). => copia de la entrada con
# 'disponible_desde' = esa hora, o nil
def self.proxima_de(keys)
k = keys.select { |x| x['activo'] != false }.min_by { |x| libre_desde(x) }
k && k.merge('disponible_desde' => libre_desde(k).iso8601(3))
end
def self.libre_desde(k)
[Time.parse(k['disponible_desde']), k['reservado_hasta'] && Time.parse(k['reservado_hasta'])].compact.max
end
def self.de_refs(refs)
refs = Array(refs)
leer['keys'].select { |k| refs.include?("#{k['provider']}/#{k['identificador']}") }
end
# Criterio ÚNICO de "libre ahora" (activa, no agotada, sin reserva vigente) y de cuál dar (la menos usada).
def self.elegir_libre(keys)
ahora = Time.now
keys
.select do |k|
k['activo'] != false &&
Time.parse(k['disponible_desde']) <= ahora &&
(k['reservado_hasta'].nil? || Time.parse(k['reservado_hasta']) <= ahora)
end
.min_by { |k| k['ultimo_uso'] ? Time.parse(k['ultimo_uso']) : Time.at(0) }
end
# Próxima key de un provider a liberarse (para responder explícito, nunca
# silencioso) — también excluye desactivadas, nunca las ofrece como "próxima".
def self.proxima(provider)
proxima_de(leer['keys'].select { |k| k['provider'] == provider })
end
end
end
-120
View File
@@ -1,120 +0,0 @@
# frozen_string_literal: true
# lib_tokens.rb — Autenticación por-individuo (D045 §10, P201/Fase2)
# ==============================================================================
# Cada individuo F1 tiene su propio token — generado y guardado en el storage
# de NEXXA, sin dependencia de candados. Se guarda el HASH del token (SHA256),
# nunca el token en sí — mismo principio que un password: no hace falta el
# valor real para VERIFICAR posesión, solo para la emisión inicial (que se
# muestra una única vez al generarlo, nunca se vuelve a mostrar después).
# ==============================================================================
require 'json'
require 'securerandom'
require 'digest'
require 'time'
require 'openssl'
require_relative 'lib_estado'
module Nexxa
module Tokens
STATE_FILE = Estado.ruta('tokens')
# Estado vía Nexxa::Estado (P335/Fase 17)
def self.leer
Estado.leer('tokens', STATE_FILE, { 'tokens' => [] })
end
def self.guardar(state)
Estado.guardar('tokens', STATE_FILE, state)
end
def self.mutar(&)
Estado.mutar('tokens', STATE_FILE, { 'tokens' => [] }, &)
end
# Genera un token nuevo para un individuo — devuelve el token EN CLARO,
# una única vez (el caller es responsable de entregárselo al individuo y
# nunca volver a mostrarlo). Si el individuo ya tenía token, lo reemplaza
# (rotación simple).
def self.generar(individuo)
token = SecureRandom.hex(32)
mutar do |state|
state['tokens'].reject! { |t| t['individuo'] == individuo }
state['tokens'] << {
'individuo' => individuo,
'token_hash' => Digest::SHA256.hexdigest(token),
'creado' => Time.now.iso8601
}
state
end
token
end
# Verifica un token recibido (ej. header Authorization) — devuelve el
# nombre del individuo si es válido, nil si no. Comparación de tiempo
# constante (security-review, P201/Fase2/2.6): comparar hashes con == a
# secas es vulnerable en teoría a timing attacks — OpenSSL.fixed_length_secure_compare
# evita que el tiempo de respuesta filtre en qué byte difiere.
def self.verificar(token)
return nil if token.to_s.strip.empty?
hash = Digest::SHA256.hexdigest(token)
entrada = leer['tokens'].find do |t|
t['token_hash'].bytesize == hash.bytesize &&
OpenSSL.fixed_length_secure_compare(t['token_hash'], hash)
end
entrada && entrada['individuo']
end
# Todos los individuos con token registrado — solo metadata (individuo +
# fecha de creación), NUNCA el hash ni el token (P201/Fase3, mismo criterio
# que Registro.todas con valor_cifrado).
def self.listar
leer['tokens'].map { |t| { 'individuo' => t['individuo'], 'creado' => t['creado'] } }
end
# Revoca el acceso de un individuo — borra su entrada, sin deshacer. El
# individuo necesita un token nuevo (generar) para volver a consultar NEXXA.
def self.revocar(individuo)
existia = nil
mutar do |state|
existia = state['tokens'].reject! { |t| t['individuo'] == individuo }
state
end
!existia.nil?
end
# Cifrado de punta a punta (P204, "Aplica Pilares" — reemplaza la
# decisión previa de diferirlo): cada individuo registra SU PROPIA clave
# pública RSA — la privada nunca sale del individuo, nunca la ve NEXXA ni
# GEMMA. Self-service: solo el individuo autenticado con SU token puede
# tocar SU propia clave (server.rb lo gatea) — ni siquiera un admin la
# puede setear por otro, porque eso rompería la propiedad de punta a
# punta (si un tercero pudiera registrar la clave pública "en nombre de"
# otro, podría sustituirla por una propia y interceptar).
def self.registrar_clave_publica(individuo:, clave_publica_pem:)
# Validar que es una clave pública RSA válida antes de guardar — falla
# rápido con un error claro en vez de guardar basura silenciosamente.
OpenSSL::PKey::RSA.new(clave_publica_pem)
mutar do |state|
entrada = state['tokens'].find { |t| t['individuo'] == individuo }
raise "Individuo sin token: #{individuo}" unless entrada
entrada['clave_publica_pem'] = clave_publica_pem
state
end
true
rescue OpenSSL::PKey::RSAError
raise 'Clave pública inválida — se espera PEM RSA (ej. openssl rsa -pubout)'
end
# nil si el individuo no registró clave — server.rb cae a texto plano en
# ese caso (compatibilidad, no rompe consumidores que todavía no migraron).
def self.clave_publica(individuo)
entrada = leer['tokens'].find { |t| t['individuo'] == individuo }
entrada && entrada['clave_publica_pem']
end
end
end
-79
View File
@@ -1,79 +0,0 @@
# frozen_string_literal: true
# lib_usos.rb — Registro de uso por individuo (P201/Fase3, D045 §11, ME-605 punto 5)
# ==============================================================================
# Trazabilidad de quién recibió qué key y cuándo — separado del dato de origen
# (cuenta_origen, en lib_registro.rb) y separado de registro.json (estado actual)
# para no mezclar "foto del ahora" con "historial acumulado". Append-only,
# JSONL — mismo espíritu que un log de bitácora: se escribe, no se reescribe.
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_estado'
module Nexxa
module Usos
LOG_FILE = Estado::USOS_LOG # fuente única de la ruta (P335/Fase 17)
# Registro COMPLETO de lo que pasa con cada key (P337/Fase 1). Códigos estables (hay filas guardadas con ellos);
# nexxa-web los traduce a palabras:
EVENTOS = %w[dispensada liberada renovada pausada agotada revertida liberada-admin alta editada renombrada baja].freeze
# Qué significa cada evento en palabras: fuente ÚNICA para nexxa-web y GEMMA (viaja en /usos y /resumen)
TEXTOS = {
'dispensada' => 'entregada', 'liberada' => 'devuelta', 'renovada' => 'reserva renovada',
'pausada' => 'en pausa por límite del proveedor', 'agotada' => 'agotada (cuota)', 'revertida' => 'reporte deshecho',
'liberada-admin' => 'liberada por admin', 'alta' => 'dada de alta', 'editada' => 'editada',
'renombrada' => 'renombrada', 'baja' => 'dada de baja',
'agotada-previa' => 'bloqueada (registro anterior a 2.0.0: no distingue pausa de cuota)'
}.freeze
# Un 'agotada' sin 'hasta' es de antes de 2.0.0, cuando un 429 de un minuto también se guardaba como agotada:
# contarlo como cuota inflaría los agotamientos (caso real 2026-10-05: 32 en 24 h, casi todos pausas).
def self.clase(u)
u['evento'] == 'agotada' && u['hasta'].nil? ? 'agotada-previa' : u['evento']
end
# motivo: lo que contestó el proveedor (pausada/agotada), qué cambió (editada) o el nombre anterior (renombrada).
# hasta: hasta cuándo queda así (fin de la reserva o del bloqueo). Nunca valores de keys.
def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada', motivo: nil, hasta: nil)
linea = {
'provider' => provider,
'identificador' => identificador,
'individuo' => individuo,
'evento' => evento,
'en' => en.iso8601,
'motivo' => motivo,
'hasta' => hasta
}
Estado.usos_registrar(linea)
end
# Más reciente primero. Filtros opcionales; horas: solo la ventana de las últimas N horas
def self.historial(provider: nil, identificador: nil, individuo: nil, evento: nil, horas: nil, limit: 100)
Estado.usos_historial(provider: provider, identificador: identificador, individuo: individuo, evento: evento,
desde: horas && (Time.now - (horas.to_f * 3600)), limit: limit)
.map { |u| u.merge('clase' => clase(u), 'texto' => TEXTOS.fetch(clase(u), u['evento'])) }
end
# Lo que muestra el Dashboard (P337/Fase 1): cuántas keys en cada estado AHORA (todos los estados, también los
# que están en 0: un número ausente se presta a interpretar) y qué pasó en las últimas N horas, en total y por key.
# keys: Registro.todas_con_estado. eventos: inyectable (tests); por defecto, el registro de la ventana.
def self.resumen(keys, horas: 24, eventos: nil)
eventos ||= historial(horas: horas, limit: 1_000_000)
contar = ->(lista) { (EVENTOS + ['agotada-previa']).to_h { |e| [e, lista.count { |u| clase(u) == e }] } }
por_key = keys.map do |k|
propios = eventos.select { |u| u['provider'] == k['provider'] && u['identificador'] == k['identificador'] }
k.slice('provider', 'identificador', 'estado', 'hasta', 'por', 'motivo', 'ultimo_uso', 'ultimo_individuo')
.merge('eventos' => contar.call(propios), 'ultimo_evento' => propios.first)
end
{
'horas' => horas,
'textos' => TEXTOS,
'ahora' => Nexxa::Registro::ESTADOS.to_h { |e| [e, keys.count { |k| k['estado'] == e }] },
'eventos' => contar.call(eventos),
'por_key' => por_key.sort_by { |k| [k['provider'].to_s, k['identificador'].to_s] }
}
end
end
end
-15
View File
@@ -1,15 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# nexxa.rb — Entry point del router (uso CLI y, a futuro, canal apids chat)
# Uso: ruby nexxa.rb "disponible gemini"
require_relative 'router'
estimulo = ARGV.join(' ')
if estimulo.empty?
puts "Uso: ruby nexxa.rb \"disponible <provider>\""
exit 1
end
puts Nexxa::Router.procesar(estimulo)
-44
View File
@@ -1,44 +0,0 @@
# frozen_string_literal: true
# router.rb — Matching exacto estímulo → estado, cero semántica en runtime
# ==============================================================================
# NEXXA-F1 (P200) — sin LLM en ningún punto (D045 §1/§4). Responde consultas de
# pares vía apids chat con formato fijo, nunca silencioso ante agotamiento.
# ==============================================================================
require_relative 'lib_registro'
module Nexxa
module Router
# estimulo esperado: "disponible <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
-988
View File
@@ -1,988 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# server.rb — Servicio HTTP/API de NEXXA (P201/Fase2-4)
# ==============================================================================
# A diferencia de gemma/tools/docs_web/server.rb y gemma/tools/sala/hub.rb
# (que corren en el MISMO host que nginx, loopback alcanza), NEXXA vive en su
# propio LXC (10.0.10.163) — srvv-proxy (10.0.10.117) le hace proxy_pass
# cross-host, así que necesita escuchar en la interfaz real, no en loopback
# (corregido P201/Fase4 tras el primer 502 real contra nexxa.frlr.utn.edu.ar).
# Sigue sin exposición directa a internet: la LAN 10.0.10.0/24 no es
# ruteable desde afuera, nginx sigue siendo el único gateway público.
#
# Dos superficies de auth, ambas resueltas por NEXXA mismo — sin nginx
# Basic Auth ni credenciales de GEMMA (corrección del Operador, P201/Fase4):
# - GET /disponible/<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
COMMIT_FILE = File.expand_path('COMMIT', __dir__).freeze
def version_actual
File.read(VERSION_FILE).strip
end
# Cifrado de punta a punta (P204) — arma el fragmento de respuesta con el
# valor real, cifrado para EL INDIVIDUO SI tiene clave pública registrada, en
# texto plano si no (compatibilidad — un consumidor que todavía no migró a
# su propia clave sigue funcionando, protegido solo por TLS como antes).
# Un solo lugar decide esto — reusado por la dispensa normal y por
# "siguiente" en /reportar, para no repetir el criterio.
def empaquetar_valor(individuo, valor)
clave_publica = Nexxa::Tokens.clave_publica(individuo)
if clave_publica
{ valor_cifrado: Nexxa::Envelope.cifrar_para(clave_publica, valor), cifrado: true }
else
{ valor: valor, cifrado: false }
end
end
# Todo reinicio del servicio invalida las sesiones activas (P204/Fase4, pedido
# del Operador) — hace el reinicio visible: quien estaba conectado tiene que
# volver a loguearse, en vez de seguir viendo el panel sin saber si el deploy
# surtió efecto. Sesiones son de por sí efímeras (SESSION_TTL=8h, lib_auth.rb) —
# perderlas en un restart no es una pérdida real, es la señal que se pidió.
Nexxa::Auth.guardar_sesiones({})
server = WEBrick::HTTPServer.new(
Port: PORT,
BindAddress: '0.0.0.0',
Logger: WEBrick::Log.new($stdout, WEBrick::Log::INFO),
AccessLog: [[$stdout, WEBrick::AccessLog::COMMON_LOG_FORMAT]]
)
def individuo_autenticado(req)
auth = req['Authorization'].to_s
return nil unless auth.start_with?('Bearer ')
Nexxa::Tokens.verificar(auth.sub('Bearer ', '').strip)
end
# Sesión del Operador (P201/Fase4) — cookie de sesión propia de NEXXA, no
# Basic Auth de nginx. req.cookies ya viene parseado por WEBrick (stdlib).
def token_de_sesion(req)
cookie = req.cookies.find { |c| c.name == SESSION_COOKIE }
cookie&.value
end
def sesion_actual(req)
Nexxa::Auth.sesion(token_de_sesion(req))
end
def operador_autenticado?(req)
!sesion_actual(req).nil?
end
# Quién hizo algo desde la web, para el registro de usos (P337/Fase 1)
def quien(req)
u = sesion_actual(req)&.dig('usuario')
u ? "web:#{u}" : 'api'
end
def admin_autenticado?(req)
sesion_actual(req)&.dig('perfil') == 'admin'
end
# WEBrick::Cookie (gem webrick 1.8.1) no expone HttpOnly/SameSite — se arma
# el header Set-Cookie a mano para tener las 3 flags recomendadas (OWASP):
# HttpOnly (JS no puede leerla), Secure (solo por HTTPS — nginx termina TLS
# por delante), SameSite=Strict (mitiga CSRF). Leer sigue vía req.cookies
# (eso sí soportado), esto solo afecta cómo se escribe.
def set_cookie_sesion(res, token)
res['Set-Cookie'] = "#{SESSION_COOKIE}=#{token}; Path=/; Max-Age=#{Nexxa::Auth::SESSION_TTL}; HttpOnly; Secure; SameSite=Strict"
end
def borrar_cookie_sesion(res)
res['Set-Cookie'] = "#{SESSION_COOKIE}=; Path=/; Max-Age=0; HttpOnly; Secure; SameSite=Strict"
end
def rechazar_no_autenticado(res)
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'No autenticado' }.to_json
end
def rechazar_no_admin(res)
res.status = 403
res.content_type = 'application/json'
res.body = { error: 'Requiere perfil admin' }.to_json
end
NEXXA_APP_FILE = File.expand_path('index.html', WEB_DIR).freeze
LOGIN_FILE = File.expand_path('login.html', WEB_DIR).freeze
# GET / — sirve login.html o index.html según la sesión (P201/Fase4). Se lee
# del disco en cada request (mismo criterio que docs_web/server.rb, P164).
#
# Cache busting (P335, 2026-10-04): los .js/.css los sirve un FileHandler estático y el navegador se quedaba con el
# app.js viejo tras un deploy (el Operador veía el menú Pools nuevo pero la sección vacía). Al servir el HTML se le
# agrega ?v=<VERSION> a cada /js/ y /css/: cada versión nueva obliga a bajar los archivos nuevos. El HTML en sí no se
# cachea (no-cache), así siempre trae la versión vigente.
def html_con_version(ruta)
# encoding explícito: systemd corre con locale C (US-ASCII) y el gsub sobre un HTML con acentos daba 500 (1.4.1)
File.read(ruta, encoding: 'UTF-8').gsub(%r{(["'])(/(?:js|css)/[^"'?]+\.(?:js|css))\1}) { "#{$1}#{$2}?v=#{version_actual}#{$1}" }
end
server.mount_proc '/' do |req, res|
res.status = 200
res.content_type = 'text/html; charset=utf-8'
res['Cache-Control'] = 'no-cache'
res.body = html_con_version(operador_autenticado?(req) ? NEXXA_APP_FILE : LOGIN_FILE)
end
# Estáticos (css/js) — públicos a propósito: login.html los necesita antes de
# autenticar. WEBrick::HTTPServlet::FileHandler es la clase estándar de la
# stdlib para esto (no reinventar servido de estáticos).
server.mount('/css', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'css'))
server.mount('/js', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'js'))
# POST /login — body {usuario, password}. Si matchea, crea sesión y devuelve la cookie.
server.mount_proc '/login' do |req, res|
res.content_type = 'application/json'
if req.request_method != 'POST'
res.status = 405
res.body = { error: 'Método no permitido — usar POST' }.to_json
next
end
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
next
end
entrada = Nexxa::Auth.autenticar(usuario: body['usuario'], password: body['password'])
if entrada
token = Nexxa::Auth.crear_sesion(entrada['usuario'], entrada['perfil'])
set_cookie_sesion(res, token)
res.status = 200
res.body = { ok: true, usuario: entrada['usuario'], perfil: entrada['perfil'] }.to_json
else
res.status = 401
res.body = { error: 'Usuario o password incorrectos' }.to_json
end
end
# POST /logout — cierra la sesión actual, si había una.
server.mount_proc '/logout' do |req, res|
res.content_type = 'application/json'
Nexxa::Auth.cerrar_sesion(token_de_sesion(req))
borrar_cookie_sesion(res)
res.status = 200
res.body = { ok: true }.to_json
end
# GET /session — quién está logueado ahora (para que el frontend sepa qué
# mostrar, ej. la sección Usuarios solo si perfil admin).
# GET /version — build stamp público (P204/Fase4) — sin auth a propósito,
# mismo criterio que css/js: login.html también necesita mostrarlo, antes de
# autenticar.
server.mount_proc '/version' do |req, res|
res.status = 200
res.content_type = 'application/json'
# commit: el que dejó `gemma nexxa desplegar` (organismo/COMMIT, generado al desplegar, nunca en el repo — P335/F15)
commit = File.exist?(COMMIT_FILE) ? File.read(COMMIT_FILE).strip : nil
res.body = { version: version_actual, commit: commit }.to_json
end
server.mount_proc '/session' do |req, res|
res.content_type = 'application/json'
sesion = sesion_actual(req)
if sesion
res.status = 200
res.body = sesion.to_json
else
rechazar_no_autenticado(res)
end
end
# GET /keys — metadata de todas las keys, NUNCA el valor
# PATCH /keys/<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
# Cada key trae en qué pools está (P335/Fase 12): la sección APIs lo muestra y avisa al eliminar
pools = Nexxa::Pools.leer
# Y su estado de la taxonomía calculado acá (P337/Fase 1): la web lo muestra, no lo recalcula
res.body = Nexxa::Registro.todas_con_estado.map { |k| k.merge('pools' => Nexxa::Pools.de_key(k['provider'], k['identificador'], pools)) }.to_json
end
# POST /keys/<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
# Renombrar primero (P335/Fase 13): registro + pools; el resto de los campos se aplica sobre el nombre nuevo
nuevo = body['identificador'].to_s.strip
if !nuevo.empty? && nuevo != identificador
Nexxa::Registro.renombrar(provider: provider, de: identificador, a: nuevo, usuario: sesion_actual(req)&.dig('usuario'))
Nexxa::Pools.renombrar_key(provider: provider, de: identificador, a: nuevo)
identificador = nuevo
end
entrada = Nexxa::Registro.actualizar(
provider: provider,
identificador: identificador,
cuenta_origen: body['cuenta_origen'],
reset_segundos: body['reset_segundos']&.to_i,
activo: body.key?('activo') ? body['activo'] : nil, por: quien(req)
)
res.status = 200
res.body = entrada.reject { |k, _| k == 'valor_cifrado' }.to_json
rescue RuntimeError => e
res.status = e.message.start_with?('Key no encontrada') ? 404 : 409
res.body = { error: e.message }.to_json
end
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
partes = partes_de(req)
if partes.size != 2
res.status = 400
res.body = { error: 'Uso: DELETE /keys/<provider>/<identificador>' }.to_json
return
end
provider, identificador = partes
borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador, por: quien(req))
Nexxa::Pools.olvidar_key(provider: provider, identificador: identificador) if borrado # sin refs colgadas (P335)
if borrado
res.status = 200
res.body = { ok: true }.to_json
else
res.status = 404
res.body = { error: 'Key no encontrada' }.to_json
end
end
end
server.mount '/keys', KeysServlet
# /pools — pools por individuo (P335/Fase 5): GET para cualquier operador (estado de cada key, nunca valores);
# asignar/quitar solo admin (ME-682/ME-683, gate explícito en cada escritura).
# GET /pools
# POST /pools/<individuo>/<rol> body {provider, identificador}
# PUT /pools/<individuo>/<rol> body {refs: ["prov/id", ...]} (reemplaza; [] = vaciar)
# POST /pools/<individuo>/<rol>/<provider>/<identificador>/mover (al otro rol)
# 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)
if partes.size == 5 && partes[4] == 'mover'
a = Nexxa::Pools.mover(individuo: partes[0], de: partes[1], provider: partes[2], identificador: partes[3])
return responder(res, 200, { individuo: partes[0], de: partes[1], a: a })
end
return responder(res, 400, { error: 'Uso: POST /pools/<individuo>/<mente|red> {provider, identificador} | POST /pools/<individuo>/<rol>/<provider>/<id>/mover' }) if partes.size != 2
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
return responder(res, 400, { error: 'JSON inválido' })
end
pool = Nexxa::Pools.asignar(individuo: partes[0], rol: partes[1],
provider: body['provider'].to_s, identificador: body['identificador'].to_s)
responder(res, 200, { individuo: partes[0], rol: partes[1], pool: pool })
rescue RuntimeError => e
responder(res, 400, { error: e.message })
end
# Editar el pool entero desde nexxa-web (P335/Fase 12): valida todas las refs antes de escribir
def do_PUT(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
partes = partes_de(req)
return responder(res, 400, { error: 'Uso: PUT /pools/<individuo>/<mente|red> {refs: ["provider/identificador", ...]}' }) if partes.size != 2
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
return responder(res, 400, { error: 'JSON inválido' })
end
return responder(res, 400, { error: "Falta 'refs' (lista; vacía = vaciar el pool)" }) unless body['refs'].is_a?(Array)
pool = Nexxa::Pools.reemplazar(individuo: partes[0], rol: partes[1], refs: body['refs'])
responder(res, 200, { individuo: partes[0], rol: partes[1], pool: pool })
rescue RuntimeError => e
responder(res, 400, { error: e.message })
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
partes = partes_de(req)
return responder(res, 400, { error: 'Uso: DELETE /pools/<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.
# P337/Fase 1: registro completo con filtros — ?provider=&identificador=&individuo=&evento=&horas=&limit= (máx 2000)
server.mount_proc '/usos' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
q = req.query
filtros = %w[provider identificador individuo evento].to_h { |k| [k.to_sym, q[k].to_s.empty? ? nil : q[k].to_s] }
limit = (q['limit'] || 100).to_i.clamp(1, 2000)
horas = q['horas'].to_s.empty? ? nil : q['horas'].to_f
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.historial(**filtros, horas: horas, limit: limit).to_json
end
# GET /resumen?horas=24 — P337/Fase 1: cuántas keys en cada estado AHORA y qué pasó en la ventana (por evento y por
# key). Lo que el Dashboard muestra, calculado acá.
server.mount_proc '/resumen' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
horas = (req.query['horas'] || 24).to_f.clamp(1, 24 * 31)
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.resumen(Nexxa::Registro.todas_con_estado, horas: horas).to_json
end
# GET /consumidores — individuos con token registrado (metadata)
# POST /consumidores — genera/rota token para un individuo, body
# {individuo} — el token en claro se entrega
# UNA VEZ en la respuesta (mismo criterio que
# el alta de una key: se muestra al crear,
# nunca más — el Operador lo guarda en
# candados o se lo entrega al individuo)
# DELETE /consumidores/<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
# Cada individuo trae el resumen de sus pools (P335/Fase 12): Individuos y Dashboard lo muestran
res.body = Nexxa::Tokens.listar.map { |c| c.merge('pools' => Nexxa::Pools.resumen(c['individuo'])) }.to_json
end
def do_POST(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
return
end
individuo = body['individuo'].to_s.strip
if individuo.empty?
res.status = 400
res.body = { error: 'Falta "individuo"' }.to_json
return
end
token = Nexxa::Tokens.generar(individuo)
res.status = 201
res.body = { individuo: individuo, token: token }.to_json
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
individuo = individuo_de(req)
if individuo.empty?
res.status = 400
res.body = { error: 'Uso: DELETE /consumidores/<individuo>' }.to_json
return
end
revocado = Nexxa::Tokens.revocar(individuo)
Nexxa::Pools.olvidar_individuo(individuo) if revocado # sin token no pide: sus pools no quedan colgados
if revocado
res.status = 200
res.body = { ok: true }.to_json
else
res.status = 404
res.body = { error: 'Individuo no encontrado' }.to_json
end
end
end
server.mount '/consumidores', ConsumidoresServlet
# GET /usuarios — metadata de todos los usuarios del panel
# POST /usuarios — alta, body {usuario, password, perfil}
# PATCH /usuarios/<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'
# Del mismo pool (rol) o del mismo provider, elegida y reservada en un solo paso atómico (P335/Fase 17)
siguiente = Nexxa::Pools.dispensar(individuo, nombre)
if siguiente&.dig('valor_cifrado')
valor_siguiente = Nexxa::Registro.descifrar(siguiente['valor_cifrado'])
resp[:siguiente] = { provider: siguiente['provider'], identificador: siguiente['identificador'] }
.merge(empaquetar_valor(individuo, valor_siguiente))
end
end
res.status = 200
res.content_type = 'application/json'
res.body = resp.to_json
next
end
# GET /disponible/<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 }
# Elegir y reservar en UN paso atómico (P335/Fase 17): antes se elegía y se reservaba después, y dos consumidores
# simultáneos podían recibir la misma key. dry_run solo mira, nunca reserva.
key = req.query['dry_run'] ? Nexxa::Pools.disponible(individuo, nombre) : Nexxa::Pools.dispensar(individuo, nombre)
if key.nil?
proxima = Nexxa::Pools.proxima(individuo, nombre)
res.status = 404
res.content_type = 'application/json'
res.body = if proxima
{ error: 'agotado', proxima_disponible: proxima['disponible_desde'] }.merge(donde).to_json
else
{ error: 'sin_keys_registradas' }.merge(donde).to_json
end
next
end
provider = key['provider']
# dry_run (P204, prp08 §"verificar sin consumir"): confirmar disponibilidad sin
# dispensar el valor ni marcar uso — nunca incluye 'valor' en la respuesta,
# pensado para health-check/verificación (evita que probar el mecanismo
# requiera recibir el secreto — ver incidente de sesión, ME-631).
if req.query['dry_run']
res.status = 200
res.content_type = 'application/json'
res.body = { provider: provider, identificador: key['identificador'], disponible: true }.to_json
next
end
valor = key['valor_cifrado'] && Nexxa::Registro.descifrar(key['valor_cifrado'])
if valor.nil?
# Key registrada solo como metadata (no migrada todavía, D045 §9→§10) —
# respuesta explícita, nunca silenciosa (mismo criterio que router.rb)
res.status = 409
res.content_type = 'application/json'
res.body = { error: 'sin_valor_migrado', provider: provider, identificador: key['identificador'] }.to_json
next
end
# La reserva corta de contención (P204/Fase3, D045 §8) ya la aplicó dispensar: no asume agotamiento (eso lo
# decide el consumidor vía POST .../reportar), solo evita que 2 consumidores reciban la misma key.
res.status = 200
res.content_type = 'application/json'
res.body = { provider: provider, identificador: key['identificador'] }.merge(empaquetar_valor(individuo, valor)).to_json
end
# POST /consumidor/clave-publica — cifrado de punta a punta (P204): el
# individuo registra SU PROPIA clave pública RSA (PEM), self-service — solo
# puede tocar la suya (individuo_autenticado la resuelve por su propio
# token, no hay parámetro "para quién" que alguien pueda falsear). La
# privada nunca llega a NEXXA, ni siquiera de paso — el individuo la genera
# y se la guarda él mismo, acá solo entra la mitad pública.
server.mount_proc '/consumidor/clave-publica' do |req, res|
individuo = individuo_autenticado(req)
if individuo.nil?
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Token inválido o ausente (header Authorization: Bearer <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'],
por: quien(req)
)
res.status = 201
res.content_type = 'application/json'
res.body = { ok: true, provider: body['provider'], identificador: body['identificador'] }.to_json
end
# /checkin — reporte proactivo de estado de individuos F1 (P216). Mismo
# patrón de auth que /disponible: individuo_autenticado(req) — el token YA
# identifica quién reporta, nunca se confía en un id del body/path para
# escribir. Consultar (GET) exige token válido igual (cualquier consumidor
# logueado por Bearer, no solo el propio individuo) — es diagnóstico
# compartido entre el equipo F1, no un dato privado de cada uno.
server.mount_proc '/checkin' do |req, res|
individuo = individuo_autenticado(req)
if individuo.nil?
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Token inválido o ausente (header Authorization: Bearer <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
-239
View File
@@ -1,239 +0,0 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# tool_humo_pool.rb — Pool de tests de humo: rotación + salud + mecanismo de
# reserva/reporte (P204/Fase3-4)
# ==============================================================================
# Formaliza las verificaciones ad-hoc hechas durante P204 (pedido del Operador:
# re-correrlas cuando se toque el mecanismo de nuevo, no reinventarlas cada
# vez). Corre LOCAL contra lib_registro.rb — sin pasar por HTTP/server.rb, mismo
# criterio que las pruebas aisladas de Fase 3.
#
# Todo lo destructivo (reserva, rotación, reportar) usa un provider/keys
# DESCARTABLES ('selftest', nunca un provider real) — nunca toca keys reales
# ni su estado. La única sección de solo-lectura ("salud actual") sí lee el
# registro real, pero nunca dispensa ni reserva nada (mismo espíritu que
# dry_run) — reporta el estado tal cual está, no lo cambia.
# ==============================================================================
# Uso: ruby tool_humo_pool.rb (correr como usuario 'nexxa' — dueño de
# registro.json — o con permisos de lectura/
# escritura sobre él)
# ==============================================================================
require_relative 'lib_registro'
require_relative 'lib_tokens'
require_relative 'lib_envelope'
require 'openssl'
require 'base64'
PROVIDER_TEST = 'selftest'
INDIVIDUO_TEST = 'selftest'
$fallas = 0
$total = 0
def test(nombre)
$total += 1
yield
puts " ✅ #{nombre}"
rescue StandardError => e
$fallas += 1
puts " ❌ #{nombre} — #{e.class}: #{e.message}"
end
def assert(cond, msg)
raise msg unless cond
end
def limpiar_provider_test
Nexxa::Registro.leer['keys']
.select { |k| k['provider'] == PROVIDER_TEST }
.each { |k| Nexxa::Registro.eliminar(provider: PROVIDER_TEST, identificador: k['identificador']) }
end
puts "\n🧪 Pool de tests NEXXA — rotación + salud + reserva/reporte (P204)\n\n"
# ------------------------------------------------------------------
puts '→ Salud actual (solo lectura, keys REALES — nunca dispensa)'
ahora = Time.now
providers_reales = Nexxa::Registro.leer['keys'].map { |k| k['provider'] }.uniq
test('lee el registro real sin explotar') do
assert(Nexxa::Registro.leer.is_a?(Hash), 'leer() no devolvió un Hash')
end
providers_reales.each do |provider|
# El estado de la taxonomía única (Registro.estado_de, P337/Fase 1), nunca recalculado acá
Nexxa::Registro.estado_pool(provider, ahora).each do |k|
icono = { 'disponible' => '🟢', 'en_uso' => '🔵', 'en_pausa' => '🟡', 'agotada' => '🔴', 'desactivada' => '⚪',
'sin_valor' => '▫️' }[k['estado']]
puts " #{icono} #{provider}/#{k['identificador']}: #{k['estado']}#{k['hasta'] ? " hasta #{k['hasta']}" : ''}"
end
end
# ------------------------------------------------------------------
puts "\n→ Mecanismo de reserva/reporte (provider descartable '#{PROVIDER_TEST}')"
limpiar_provider_test
Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: 'k1', cuenta_origen: 'test', reset_segundos: 3)
test('key recén registrada está disponible') do
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'no debería estar nil')
end
test('reservar bloquea la key para otros consumidores') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'sigue apareciendo disponible con reserva activa')
end
test('reportar rechaza a un individuo que no tiene la reserva') do
begin
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testB', estado: 'sana')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test("estado 'sana' renueva la reserva (sigue no disponible)") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'sana')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería seguir reservada tras "sana"')
end
test("estado 'liberada' libera de inmediato") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'liberada')
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar disponible tras "liberada"')
end
test("estado 'agotada' con liberar_en_segundos aplica el valor custom, no reset_segundos") do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'agotada', liberar_en_segundos: 2)
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería estar agotada inmediatamente después')
sleep 2.2
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería liberarse tras los 2s custom')
end
test('reserva sin ningún reporte vence sola (pasivo)') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
state = Nexxa::Registro.leer
entrada = state['keys'].find { |k| k['identificador'] == 'k1' }
entrada['reservado_hasta'] = (Time.now - 1).iso8601(3)
Nexxa::Registro.guardar(state)
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar libre con reserva vencida')
end
# ------------------------------------------------------------------
puts "\n→ Rotación del pool (menos usada recientemente, no siempre la primera)"
limpiar_provider_test
%w[k1 k2 k3].each { |id| Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: id, cuenta_origen: 'test', reset_segundos: 100) }
# ultimo_uso explícito y bien separado (determinismo — 3 registrar() seguidos
# pueden empatar en el mismo milisegundo según qué tan rápido corra la CPU/
# disco, sin relación con el mecanismo real que se está probando)
state = Nexxa::Registro.leer
base = Time.now - 30
%w[k1 k2 k3].each_with_index do |id, i|
entrada = state['keys'].find { |k| k['provider'] == PROVIDER_TEST && k['identificador'] == id }
entrada['ultimo_uso'] = (base + i).iso8601(3)
end
Nexxa::Registro.guardar(state)
test('6 pedidos seguidos rotan k1→k2→k3→k1→k2→k3, sin repetir de corrido') do
orden = []
6.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
orden << k['identificador']
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
# separación real entre picks — evita empates de milisegundo entre
# reservar() consecutivos en un loop apretado (nunca pasa en uso real:
# nadie dispensa+reporta 2 keys en el mismo milisegundo)
sleep 0.01
end
esperado = %w[k1 k2 k3 k1 k2 k3]
assert(orden == esperado, "orden real: #{orden.join('→')} (esperado: #{esperado.join('→')})")
end
test('una key agotada no entra en la rotación hasta liberarse') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot', estado: 'agotada', liberar_en_segundos: 999)
3.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
assert(k['identificador'] != 'k2', 'k2 no debería salir elegida estando agotada')
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
end
end
limpiar_provider_test
# ------------------------------------------------------------------
puts "\n→ Cifrado de punta a punta (P204, envelope RSA-OAEP)"
def limpiar_individuo_test
state = Nexxa::Tokens.leer
state['tokens'].reject! { |t| t['individuo'] == INDIVIDUO_TEST }
Nexxa::Tokens.guardar(state)
end
limpiar_individuo_test
Nexxa::Tokens.generar(INDIVIDUO_TEST)
par_test = OpenSSL::PKey::RSA.generate(2048)
test('registrar_clave_publica guarda y releer coincide exacto') do
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: par_test.public_key.to_pem)
assert(Nexxa::Tokens.clave_publica(INDIVIDUO_TEST) == par_test.public_key.to_pem, 'la clave releída no coincide con la guardada')
end
test('rechaza una clave pública inválida (no PEM)') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: 'no es una clave')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('rechaza registrar clave para un individuo sin token') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: 'no-existe-de-verdad', clave_publica_pem: par_test.public_key.to_pem)
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('Envelope.cifrar_para produce algo distinto del valor real') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
assert(cifrado != valor, 'el cifrado es igual al valor real — no cifró nada')
end
test('round-trip: cifrar con la pública + descifrar con la privada = valor original') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
descifrado = par_test.private_decrypt(Base64.strict_decode64(cifrado), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
assert(descifrado == valor, "descifrado (#{descifrado.inspect}) no coincide con el original")
end
test('la clave pública sola NO alcanza para descifrar (asimetría real)') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
begin
par_test.public_decrypt(Base64.strict_decode64(cifrado))
raise 'se pudo descifrar solo con la pública — esto NO debería pasar'
rescue OpenSSL::PKey::RSAError
# esperado — confirma que es asimétrico de verdad
end
end
test('sin clave pública registrada, empaquetar_valor cae a texto plano (compatibilidad)') do
assert(Nexxa::Tokens.clave_publica('individuo-sin-clave-nunca-registrada').nil?, 'debería ser nil para un individuo sin clave')
end
limpiar_individuo_test
# ------------------------------------------------------------------
puts "\n#{$fallas.zero? ? '✅' : '❌'} #{$total - $fallas}/#{$total} tests OK\n\n"
exit($fallas.zero? ? 0 : 1)
-254
View File
@@ -1,254 +0,0 @@
# frozen_string_literal: true
# estado_test.rb — Nexxa::Estado (P335/Fase 17): motor archivo con concurrencia REAL entre procesos y motor pg con una
# conexión simulada (no toca ningún Postgres). Corre sobre una COPIA de organismo/. ruby servicios/nexxa/test/estado_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
require 'json'
require 'stringio'
DIR_ESTADO = Dir.mktmpdir('nexxa-estado')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_ESTADO) }
require File.join(DIR_ESTADO, 'lib_estado')
require File.join(DIR_ESTADO, 'lib_registro')
require File.join(DIR_ESTADO, 'lib_pools')
require File.join(DIR_ESTADO, 'cli_estado')
Minitest.after_run { FileUtils.rm_rf(DIR_ESTADO) }
class EstadoArchivoTest < Minitest::Test
E = Nexxa::Estado
R = Nexxa::Registro
def setup
ENV.delete('NEXXA_ESTADO')
FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '*.json')] + [Nexxa::Usos::LOG_FILE])
end
def test_sin_variable_el_motor_es_archivo_y_uno_invalido_falla
assert_equal 'archivo', E.motor
ENV['NEXXA_ESTADO'] = 'mongo'
assert_raises(ArgumentError) { E.motor }
ensure
ENV.delete('NEXXA_ESTADO')
end
def test_guardar_es_0600_y_leer_devuelve_el_defecto_si_falta
ruta = File.join(DIR_ESTADO, 'x.json')
assert_equal({ 'a' => [] }, E.leer('x', ruta, { 'a' => [] }))
E.guardar('x', ruta, { 'a' => [1] })
assert_equal '600', format('%o', File.stat(ruta).mode & 0o777)
assert_equal({ 'a' => [1] }, E.leer('x', ruta, {}))
end
# La carrera que cierra la fase: 2 procesos x 50 incrementos sobre el mismo archivo no pierden ninguno
def test_mutar_no_pierde_escrituras_entre_procesos
ruta = File.join(DIR_ESTADO, 'contador.json')
pids = 2.times.map do
fork { 50.times { E.mutar('contador', ruta, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } } }
end
pids.each { |p| Process.wait(p) }
assert_equal 100, E.leer('contador', ruta, {})['n']
end
# Dispensa atómica: 6 procesos piden a la vez de un pool de 3 keys — nunca la misma key a dos, y 3 se quedan sin
def test_dispensar_nunca_entrega_la_misma_key_dos_veces
pasado = (Time.now - 3600).iso8601(3)
R.guardar('keys' => %w[k1 k2 k3].map do |i|
{ 'provider' => 'p', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 60, 'valor_cifrado' => 'x' }
end)
lectores = 6.times.map do |n|
r, w = IO.pipe
pid = fork do
r.close
w.write(R.reservar_libre(individuo: "ind#{n}", provider: 'p')&.dig('identificador').to_s)
w.close
end
w.close
[pid, r]
end
entregadas = lectores.map { |pid, r| Process.wait(pid) && r.read.tap { r.close } }.reject(&:empty?)
assert_equal %w[k1 k2 k3], entregadas.sort
end
def test_una_key_solo_metadata_se_devuelve_sin_reservar
R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'm', 'disponible_desde' => (Time.now - 60).iso8601(3) }])
entrada = R.reservar_libre(individuo: 'i', provider: 'p')
assert_equal 'm', entrada['identificador']
assert_nil R.leer['keys'].first['reservado_por']
end
# La hora de la próxima libre incluye la reserva: con todas reservadas, nunca una hora pasada (caso real 2026-10-05)
def test_proxima_considera_la_reserva
ahora = Time.now
R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'k', 'disponible_desde' => (ahora - 3600).iso8601(3),
'reservado_por' => 'x', 'reservado_hasta' => (ahora + 600).iso8601(3) }])
assert_operator Time.parse(R.proxima('p')['disponible_desde']), :>, ahora
assert_nil R.disponible('p')
end
def test_usos_en_archivo_mas_reciente_primero
E.usos_registrar('provider' => 'p', 'identificador' => 'a', 'individuo' => 'i', 'evento' => 'dispensada', 'en' => '2026-10-05T01:00:00-03:00')
E.usos_registrar('provider' => 'p', 'identificador' => 'b', 'individuo' => 'i', 'evento' => 'agotada', 'en' => '2026-10-05T02:00:00-03:00')
assert_equal %w[b a], E.usos_historial.map { |u| u['identificador'] }
assert_equal ['a'], E.usos_historial(identificador: 'a').map { |u| u['identificador'] }
end
end
# Conexión simulada con la forma de PG::Connection que usa Estado (exec, exec_params, transaction_status)
class ConexionFalsa
attr_reader :sql
def initialize = (@filas = {}; @usos = []; @sql = []; @tx = 0)
def transaction_status = @tx
def exec(q)
@sql << q
return [{ 'n' => @usos.size }] if q.start_with?('SELECT count(*)')
return @usos.map { |u| %w[provider identificador individuo evento en].zip(u).to_h } if q.include?('FROM usos ORDER BY id')
@tx = 2 if q == 'BEGIN'
if %w[COMMIT ROLLBACK].include?(q)
@tx = 0
@filas = @copia if q == 'ROLLBACK' && @copia
end
@copia = Marshal.load(Marshal.dump(@filas)) if q == 'BEGIN'
[]
end
def exec_params(q, params)
@sql << q.split.first(2).join(' ')
case q
when /\AINSERT INTO usos/m then @usos << params
when /\AINSERT INTO estado .* DO NOTHING/m then @filas[params[0]] ||= params[1]
when /\AINSERT INTO estado/m, /\AUPDATE estado/m then @filas[params[0]] = params[1]
when /\ASELECT valor FROM estado/m then return @filas.key?(params[0]) ? [{ 'valor' => @filas[params[0]] }] : []
end
[]
end
end
class EstadoPgTest < Minitest::Test
E = Nexxa::Estado
def setup
ENV['NEXXA_ESTADO'] = 'pg'
@c = ConexionFalsa.new
E.con = @c
end
def teardown
ENV.delete('NEXXA_ESTADO')
E.con = nil
end
def test_leer_guardar_por_clave_sin_tocar_archivos
assert_equal({ 'keys' => [] }, E.leer('registro', '/no/existe.json', { 'keys' => [] }))
E.guardar('registro', '/no/existe.json', { 'keys' => [1] })
assert_equal({ 'keys' => [1] }, E.leer('registro', '/no/existe.json', {}))
end
def test_mutar_hace_begin_commit_y_devuelve_el_valor_nuevo
nuevo = E.mutar('pools', nil, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) }
assert_equal({ 'n' => 1 }, nuevo)
assert_equal 'BEGIN', @c.sql.first
assert_equal 'COMMIT', @c.sql.last
assert(@c.sql.any? { |q| q.include?('SELECT') })
assert_equal 0, @c.transaction_status
end
def test_un_error_en_el_bloque_hace_rollback_y_no_guarda
E.guardar('pools', nil, { 'n' => 5 })
assert_raises(RuntimeError) { E.mutar('pools', nil, {}) { |_v| raise 'no' } }
assert_includes @c.sql, 'ROLLBACK'
assert_equal 0, @c.transaction_status
assert_equal({ 'n' => 5 }, E.leer('pools', nil, {}))
end
def salida_no_local
E.mutar('pools', nil, {}) { |_v| return :afuera }
end
def test_un_return_en_el_bloque_no_deja_la_transaccion_abierta
assert_equal :afuera, salida_no_local
assert_equal 'ROLLBACK', @c.sql.last
assert_equal 0, @c.transaction_status
end
end
class CliEstadoTest < Minitest::Test
E = Nexxa::Estado
C = Nexxa::CliEstado
def setup
ENV.delete('NEXXA_ESTADO')
FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '{*.json,.*.json,*.tgz}')] + [E::USOS_LOG])
E.con = ConexionFalsa.new
C.instance_variable_set(:@usos_archivo, nil)
E.archivo_guardar(E.ruta('registro'), { 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] })
E.archivo_guardar(E.ruta('usuarios'), [{ 'usuario' => 'admin' }])
File.write(E::USOS_LOG, %({"provider":"p","identificador":"k1","individuo":"i","evento":"dispensada","en":"2026-10-05T01:00:00-03:00"}\n))
end
def teardown
E.con = nil
end
def corre(accion)
out = StringIO.new
[C.call(accion, salida: out), out.string]
end
def test_migrar_es_idempotente_y_respalda_antes_de_escribir
codigo, texto = corre('migrar')
assert_equal 0, codigo, texto
assert_match(/registro: migrada/, texto)
assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size
assert_equal({ 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }, E.pg_leer('registro', nil))
codigo2, texto2 = corre('migrar')
assert_equal 0, codigo2
assert_match(/igual: pg ya coincide/, texto2)
assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size, 'la segunda corrida no respalda ni escribe'
end
# Caso real 2026-10-05 02:43: usos.log de antes de P204/Fase 3 sin 'evento' frenó la activación (columna NOT NULL)
def test_migrar_completa_el_evento_de_los_usos_viejos
File.write(E::USOS_LOG, %({"provider":"p","identificador":"k0","individuo":"i","en":"2026-05-01T10:00:00-03:00"}\n), mode: 'a')
C.instance_variable_set(:@usos_archivo, nil)
codigo, texto = corre('migrar')
assert_equal 0, codigo, texto
eventos = E.con.instance_variable_get(:@usos).map { |u| u[3] }
assert_equal %w[dispensada dispensada], eventos
end
def test_migrar_se_niega_con_el_motor_pg_ya_activo
dropin = File.join(DIR_ESTADO, 'estado.conf')
File.write(dropin, "[Service]\nEnvironment=NEXXA_ESTADO=pg\n")
out = StringIO.new
assert_equal 1, C.migrar(out, dropin: dropin)
assert_match(/ya está activo/, out.string)
assert_nil E.pg_leer('registro', nil), 'no escribió nada'
ensure
FileUtils.rm_f(dropin)
end
def test_verificar_detecta_una_diferencia
corre('migrar')
E.archivo_guardar(E.ruta('pools'), { 'individuos' => { 'gemma' => { 'mente' => ['p/k1'] } } })
codigo, texto = corre('verificar')
assert_equal 1, codigo
assert_match(/difiere de los archivos en: pools/, texto)
end
def test_exportar_es_la_vuelta_atras
corre('migrar')
E.pg_guardar('registro', { 'keys' => [] })
FileUtils.rm_f(E::USOS_LOG)
codigo, texto = corre('exportar')
assert_equal 0, codigo, texto
assert_equal({ 'keys' => [] }, E.archivo_leer(E.ruta('registro'), nil))
assert_equal 1, File.readlines(E::USOS_LOG).size
end
end
-177
View File
@@ -1,177 +0,0 @@
# frozen_string_literal: true
# humo_http_test.rb — Humo HTTP REAL del server de NEXXA sobre una copia aislada (P335/Fase 5).
# El server de prueba lo arma lib_servidor_prueba.rb (copia aislada, estado falso, 127.0.0.1). Nunca toca el nodo
# ni secretos reales. Correr después de cada cambio de la API: ruby servicios/nexxa/test/humo_http_test.rb
require 'minitest/autorun'
require 'net/http'
require 'json'
require 'time'
require_relative 'lib_servidor_prueba'
PRUEBA = ServidorPrueba.armar(individuos: %w[gemma-humo liberar-humo])
PUERTO = PRUEBA[:puerto]
TOKEN_IND = PRUEBA[:tokens]['gemma-humo']
TOKEN_LIB = PRUEBA[:tokens]['liberar-humo'] # individuo propio del test de liberar: no comparte estado
BASE_NEXXA_ORG = File.join(ServidorPrueba::BASE, 'organismo')
PID = ServidorPrueba.arrancar(PRUEBA)
Minitest.after_run { ServidorPrueba.detener(PID, PRUEBA) }
# El server invalida las sesiones al arrancar (P204): se entra por /login, como un usuario real.
def login(usuario)
password = ServidorPrueba::USUARIOS.fetch(usuario).first
r = Net::HTTP.post(URI("http://127.0.0.1:#{PUERTO}/login"), { usuario: usuario, password: password }.to_json,
'Content-Type' => 'application/json')
r['Set-Cookie'].to_s[/nexxa_session=([0-9a-f]+)/, 1] or raise "login de #{usuario} falló: #{r.code} #{r.body}"
end
SES_ADMIN = login('humo-admin')
SES_OPER = login('humo-oper')
class HumoHttpTest < Minitest::Test
def pedir(metodo, ruta, cuerpo: nil, sesion: nil, token: nil)
req = Net::HTTP.const_get(metodo.capitalize).new(ruta)
req['Cookie'] = "nexxa_session=#{sesion}" if sesion
req['Authorization'] = "Bearer #{token}" if token
if cuerpo
req['Content-Type'] = 'application/json'
req.body = cuerpo.to_json
end
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) }
[r.code.to_i, (JSON.parse(r.body) rescue r.body)]
end
def test_ciclo_pools_y_disponible_por_rol
# sin pool asignado: explícito, nunca cae al provider
assert_equal [404, 'pool_vacio'], pedir('get', '/disponible/mente', token: TOKEN_IND).then { |c, b| [c, b['error']] }
# operador lee pero no asigna; admin asigna
assert_equal 403, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_OPER)[0]
assert_equal 200, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('post', '/pools/gemma-humo/red', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0]
assert_equal 400, pedir('post', '/pools/gemma-humo/otro', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0]
c, b = pedir('get', '/pools', sesion: SES_OPER)
assert_equal [200, ['d-01']], [c, b.dig('individuos', 'gemma-humo', 'mente').map { |f| f['identificador'] }]
# mente y red dispensan su propia key, con el provider real
c, b = pedir('get', '/disponible/mente', token: TOKEN_IND)
assert_equal [200, 'deepseek', 'd-01'], [c, b['provider'], b['identificador']]
c, b = pedir('get', '/disponible/red?dry_run=1', token: TOKEN_IND)
assert_equal [200, 'gemini', 'g-02'], [c, b['provider'], b['identificador']]
# reportar por rol exige provider; con provider marca agotada con motivo y el estado lo muestra
assert_equal 400, pedir('post', '/disponible/mente/reportar', cuerpo: { identificador: 'd-01', estado: 'agotada' }, token: TOKEN_IND)[0]
c, = pedir('post', '/disponible/mente/reportar', cuerpo: { provider: 'deepseek', identificador: 'd-01', estado: 'agotada', motivo: 'humo' }, token: TOKEN_IND)
assert_equal 200, c
c, b = pedir('get', '/disponible/mente/estado', token: TOKEN_IND)
assert_equal [200, 'mente', %w[agotada humo]], [c, b['rol'], b['keys'][0].values_at('estado', 'motivo')]
assert_equal 'agotado', pedir('get', '/disponible/mente', token: TOKEN_IND)[1]['error']
# compatibilidad: por provider sigue como antes
c, b = pedir('get', '/disponible/gemini?dry_run=1', token: TOKEN_IND)
assert_equal [200, 'gemini'], [c, b['provider']]
# quitar (admin) y borrar una key la saca de todos los pools
assert_equal 200, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0]
assert_equal 404, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0]
assert_equal 200, pedir('delete', '/keys/gemini/g-02', sesion: SES_ADMIN)[0]
assert_equal({}, pedir('get', '/pools', sesion: SES_OPER)[1]['individuos'])
end
def test_liberar_desde_la_web_solo_admin
# key (groq) e individuo propios: este test no toca nada de lo que usa el ciclo de pools
assert_equal 200, pedir('get', '/disponible/groq', token: TOKEN_LIB)[0]
pedir('post', '/disponible/groq/reportar', cuerpo: { identificador: 'q-lib', estado: 'agotada', motivo: 'humo-web' }, token: TOKEN_LIB)
key = -> { pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'q-lib' } }
assert_equal %w[liberar-humo humo-web], key.call.values_at('agotada_por', 'motivo_agotada')
assert_equal 'agotado', pedir('get', '/disponible/groq', token: TOKEN_LIB)[1]['error']
assert_equal 403, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_OPER)[0]
assert_equal 404, pedir('post', '/keys/groq/no-existe/liberar', sesion: SES_ADMIN)[0]
assert_equal 200, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_ADMIN)[0]
assert_equal [nil, nil], key.call.values_at('agotada_por', 'motivo_agotada')
assert_equal 200, pedir('get', '/disponible/groq?dry_run=1', token: TOKEN_LIB)[0]
end
# Fase 12: CRUD completo (individuo propio 'crud-humo', se deja vacío al final: no interfiere con los otros tests)
def test_crud_editar_mover_vaciar_y_pools_por_key
base = '/pools/crud-humo/mente'
assert_equal 403, pedir('put', base, cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_OPER)[0]
c, b = pedir('put', base, cuerpo: { refs: %w[gemini/g-01 deepseek/d-01] }, sesion: SES_ADMIN)
assert_equal [200, %w[gemini/g-01 deepseek/d-01]], [c, b['pool']]
# una ref mala: 400 y no cambia nada
assert_equal 400, pedir('put', base, cuerpo: { refs: %w[gemini/g-01 gemini/no-existe] }, sesion: SES_ADMIN)[0]
assert_equal 400, pedir('put', base, cuerpo: { otra: 1 }, sesion: SES_ADMIN)[0]
filas = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo', 'mente').map { |f| f['identificador'] }
assert_equal %w[g-01 d-01].sort, filas.sort
# la key sabe en qué pools está
g01 = pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'g-01' }
assert_includes g01['pools'], { 'individuo' => 'crud-humo', 'rol' => 'mente' }
# mover al otro rol
c, b = pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN)
assert_equal [200, 'red'], [c, b['a']]
assert_equal 400, pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN)[0] # ya no está en mente
# vaciar los dos roles
assert_equal 200, pedir('put', base, cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('put', '/pools/crud-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo')
end
# Fase 12: Individuos con resumen de pools; revocar borra sus pools (individuo propio, creado y revocado acá)
def test_individuos_con_pools_y_revocar_los_limpia
assert_equal 201, pedir('post', '/consumidores', cuerpo: { individuo: 'revocar-humo' }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('put', '/pools/revocar-humo/mente', cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_ADMIN)[0]
c = pedir('get', '/consumidores', sesion: SES_OPER)[1].find { |x| x['individuo'] == 'revocar-humo' }
assert_equal({ 'total' => 1, 'disponibles' => 1 }, c.dig('pools', 'mente'))
assert_equal({ 'total' => 0, 'disponibles' => 0 }, c.dig('pools', 'red'))
assert_equal 200, pedir('delete', '/consumidores/revocar-humo', sesion: SES_ADMIN)[0]
assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'revocar-humo')
end
# Cache busting: el HTML referencia js/css con ?v=<versión> y no se cachea (P335: app.js viejo dejaba Pools vacío)
def test_html_trae_estaticos_con_version_y_no_se_cachea
version = File.read(File.join(BASE_NEXXA_ORG, 'VERSION')).strip
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get('/') } # sin sesión: login.html
assert_includes r.body, "/css/estilos.css?v=#{version}"
assert_includes r.body, "/js/login.js?v=#{version}"
assert_equal 'no-cache', r['Cache-Control']
req = Net::HTTP::Get.new('/')
req['Cookie'] = "nexxa_session=#{SES_OPER}"
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) } # con sesión: index.html
assert_includes r.body, "/js/app.js?v=#{version}"
assert_equal 200, Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get("/js/app.js?v=#{version}") }.code.to_i
end
# P337/Fase 1: estado calculado en /keys, registro filtrable y resumen, por HTTP y con el locale C del nodo
def test_estado_registro_y_resumen_por_http
keys = pedir('get', '/keys', sesion: SES_OPER)[1]
assert(keys.all? { |k| %w[disponible en_uso en_pausa agotada desactivada sin_valor].include?(k['estado']) })
refute(keys.any? { |k| k.key?('valor_cifrado') })
cod, usos = pedir('get', '/usos?evento=alta&horas=24', sesion: SES_OPER)
assert_equal 200, cod
assert(usos.all? { |u| u['evento'] == 'alta' })
cod, res = pedir('get', '/resumen?horas=24', sesion: SES_OPER)
assert_equal 200, cod
assert_equal keys.size, res['ahora'].values.sum
assert_equal 401, pedir('get', '/resumen')[0]
end
# Fase 13: renombrar una key (key propia d-ren; vuelve a su nombre al final)
def test_renombrar_key_actualiza_pools_y_valida
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: %w[deepseek/d-ren] }, sesion: SES_ADMIN)[0]
assert_equal 403, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2' }, sesion: SES_OPER)[0]
assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'D REN' }, sesion: SES_ADMIN)[0]
assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-01' }, sesion: SES_ADMIN)[0]
assert_equal 404, pedir('patch', '/keys/deepseek/no-existe', cuerpo: { identificador: 'x' }, sesion: SES_ADMIN)[0]
c, b = pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2', cuenta_origen: 'otra' }, sesion: SES_ADMIN)
assert_equal [200, 'd-ren2', 'otra'], [c, b['identificador'], b['cuenta_origen']]
refs = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'ren-humo', 'red').map { |f| f['identificador'] }
assert_equal ['d-ren2'], refs
assert pedir('get', '/usos', sesion: SES_OPER)[1].to_a.any? { |u| u['evento'] == 'renombrada' && u['motivo'] == 'antes d-ren' }
# limpieza: vuelve a su nombre y se vacía el pool
assert_equal 200, pedir('patch', '/keys/deepseek/d-ren2', cuerpo: { identificador: 'd-ren' }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
end
def test_sin_token_ni_sesion
assert_equal 401, pedir('get', '/disponible/mente')[0]
assert_equal 401, pedir('get', '/pools')[0]
end
end
@@ -1,60 +0,0 @@
# frozen_string_literal: true
# lib_servidor_prueba.rb — NEXXA de PRUEBA sobre una copia aislada (P335/Fase 7). Fuente única para el humo HTTP y para
# mirar nexxa-web en un navegador real sin tocar el nodo ni secretos reales.
# Copia organismo/ y web/ a un directorio temporal, cambia el server a 127.0.0.1 y un puerto libre, y siembra estado
# FALSO: master key, keys con valores inventados, usuarios humo-admin/humo-oper y tokens de individuos.
require 'tmpdir'
require 'fileutils'
require 'socket'
module ServidorPrueba
BASE = File.expand_path('..', __dir__)
USUARIOS = { 'humo-admin' => ['humo-admin-123', 'admin'], 'humo-oper' => ['humo-oper-123', 'operador'] }.freeze
KEYS = [%w[gemini g-01], %w[gemini g-02], %w[deepseek d-01], %w[groq q-lib], %w[deepseek d-ren]].freeze
module_function
# => { dir:, org:, puerto:, tokens: { individuo => token } }
def armar(individuos: %w[gemma-humo liberar-humo], puerto: nil)
dir = Dir.mktmpdir('nexxa-prueba')
%w[organismo web].each { |d| FileUtils.cp_r(File.join(BASE, d), dir) }
org = File.join(dir, 'organismo')
puerto ||= TCPServer.new('127.0.0.1', 0).then { |s| s.addr[1].tap { s.close } }
srv = File.read(File.join(org, 'server.rb'))
.sub(/^PORT = \d+/, "PORT = #{puerto}").sub("BindAddress: '0.0.0.0'", "BindAddress: '127.0.0.1'")
File.write(File.join(org, 'server.rb'), srv)
%w[lib_cripto lib_registro lib_tokens lib_auth lib_pools].each { |f| require File.join(org, f) }
Nexxa::MasterKey.generar_si_falta!
KEYS.each do |p, i|
Nexxa::Registro.registrar(provider: p, identificador: i, cuenta_origen: 'prueba', reset_segundos: 86_400, valor: "falso-#{i}", por: 'prueba')
end
USUARIOS.each { |u, (pw, perfil)| Nexxa::Auth.crear_usuario(usuario: u, password: pw, perfil: perfil) }
tokens = individuos.to_h { |ind| [ind, Nexxa::Tokens.generar(ind)] }
{ dir: dir, org: org, puerto: puerto, tokens: tokens }
end
# Arranca server.rb de la copia y espera el puerto. => pid
def arrancar(prueba, log: File.join(prueba[:dir], 'server.log'))
# Locale C como systemd en el nodo: un File.read sin encoding explícito falla acá igual que en producción (1.4.1)
pid = Process.spawn({ 'LC_ALL' => 'C', 'LANG' => 'C' }, 'ruby', 'server.rb', chdir: prueba[:org], out: File::NULL, err: log)
60.times { abierto?(prueba[:puerto]) ? break : sleep(0.25) }
raise "El server de prueba no abrió el puerto #{prueba[:puerto]} (ver #{log})" unless abierto?(prueba[:puerto])
pid
end
def detener(pid, prueba)
Process.kill('TERM', pid) rescue nil
Process.wait(pid) rescue nil
FileUtils.rm_rf(prueba[:dir])
end
def abierto?(puerto)
TCPSocket.new('127.0.0.1', puerto).close
true
rescue SystemCallError
false
end
end
-144
View File
@@ -1,144 +0,0 @@
# frozen_string_literal: true
# pools_test.rb — Pools por individuo (P335/Fase 4). Corre sobre una COPIA de organismo/ en un directorio temporal:
# registro.json/pools.json de prueba, nunca los reales. ruby servicios/nexxa/test/pools_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
DIR_PRUEBA = Dir.mktmpdir('nexxa-pools')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_PRUEBA) }
require File.join(DIR_PRUEBA, 'lib_registro')
require File.join(DIR_PRUEBA, 'lib_pools')
Minitest.after_run { FileUtils.rm_rf(DIR_PRUEBA) }
class PoolsTest < Minitest::Test
R = Nexxa::Registro
P = Nexxa::Pools
def setup
FileUtils.rm_f([R::STATE_FILE, P::STATE_FILE])
pasado = (Time.now - 3600).iso8601(3)
key = ->(p, i, extra = {}) { { 'provider' => p, 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'valor_cifrado' => 'x' }.merge(extra) }
R.guardar('keys' => [key.('gemini', 'g-01', 'ultimo_uso' => (Time.now - 60).iso8601(3)),
key.('deepseek', 'd-01', 'ultimo_uso' => (Time.now - 600).iso8601(3)),
key.('gemini', 'g-red'),
key.('gemini', 'g-off', 'activo' => false)])
end
def asignar(ind, rol, p, i) = P.asignar(individuo: ind, rol: rol, provider: p, identificador: i)
def test_pool_mezcla_proveedores_y_da_la_menos_usada
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'mente', 'deepseek', 'd-01')
k = R.disponible_en(P.refs('gemma', 'mente'))
assert_equal %w[deepseek d-01], [k['provider'], k['identificador']]
end
def test_red_separada_de_mente_y_compartida_entre_individuos
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'red', 'gemini', 'g-red')
asignar('peggy', 'red', 'gemini', 'g-red')
assert_equal 'g-red', R.disponible_en(P.refs('gemma', 'red'))['identificador']
assert_equal [{ 'individuo' => 'gemma', 'rol' => 'red' }, { 'individuo' => 'peggy', 'rol' => 'red' }],
P.de_key('gemini', 'g-red')
end
def test_asignar_es_idempotente_y_valida
2.times { asignar('gemma', 'mente', 'gemini', 'g-01') }
assert_equal ['gemini/g-01'], P.refs('gemma', 'mente')
assert_raises(RuntimeError) { asignar('gemma', 'otro', 'gemini', 'g-01') }
assert_raises(RuntimeError) { asignar('gemma', 'mente', 'gemini', 'no-existe') }
end
def test_desactivada_o_reservada_no_se_da_y_proxima_responde
asignar('gemma', 'mente', 'gemini', 'g-off')
assert_nil R.disponible_en(P.refs('gemma', 'mente'))
assert_nil R.proxima_en(P.refs('gemma', 'mente'))
asignar('gemma', 'mente', 'gemini', 'g-01')
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
assert_nil R.disponible_en(P.refs('gemma', 'mente'))
assert_equal 'g-01', R.proxima_en(P.refs('gemma', 'mente'))['identificador']
end
def test_quitar_y_olvidar_no_dejan_refs_colgadas
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('peggy', 'red', 'gemini', 'g-01')
assert P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01')
refute P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01')
assert P.olvidar_key(provider: 'gemini', identificador: 'g-01')
assert_equal({ 'individuos' => {} }, P.leer)
assert_equal '600', format('%o', File.stat(P::STATE_FILE).mode & 0o777)
end
def test_pool_vacio_no_cae_al_provider
assert_nil R.disponible_en(P.refs('nadie', 'mente'))
assert P.pool_vacio?('nadie', 'mente')
assert_nil P.disponible('nadie', 'mente')
end
# --- Fase 5: selección por nombre (rol o provider) y estado
def test_nombre_rol_usa_el_pool_y_nombre_provider_sigue_igual
asignar('gemma', 'mente', 'deepseek', 'd-01')
assert_equal 'd-01', P.disponible('gemma', 'mente')['identificador']
assert_equal 'gemini', P.disponible('gemma', 'gemini')['provider'] # compatibilidad: por provider, sin pools
refute P.pool_vacio?('gemma', 'gemini')
refute P.rol?('gemini')
end
def test_estado_por_rol_trae_provider_motivo_y_quien
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'mente', 'deepseek', 'd-01')
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma', estado: 'agotada', motivo: 'cuota diaria')
filas = P.estado('gemma', 'mente').to_h { |f| [f['identificador'], f] }
assert_equal %w[d-01 g-01], filas.keys.sort
assert_equal %w[agotada gemini gemma cuota\ diaria],
filas['g-01'].values_at('estado', 'provider', 'por', 'motivo')
assert_equal 'disponible', filas['d-01']['estado']
assert_equal 'deepseek', P.disponible('gemma', 'mente')['provider']
end
def test_con_estado_para_la_web
asignar('gemma', 'red', 'gemini', 'g-red')
assert_equal ['g-red'], P.con_estado.dig('gemma', 'red').map { |f| f['identificador'] }
end
# --- Fase 12: CRUD completo
def test_reemplazar_deja_el_pool_exacto_y_valida_todo_antes
asignar('gemma', 'mente', 'gemini', 'g-01')
assert_equal %w[deepseek/d-01 gemini/g-red], P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[deepseek/d-01 gemini/g-red])
assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente')
assert_raises(RuntimeError) { P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[gemini/g-01 gemini/no-existe]) }
assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente') # nada cambió
P.reemplazar(individuo: 'gemma', rol: 'mente', refs: [])
assert_equal({ 'individuos' => {} }, P.leer)
end
def test_mover_entre_roles
asignar('gemma', 'mente', 'gemini', 'g-01')
assert_equal 'red', P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01')
assert_equal [], P.refs('gemma', 'mente')
assert_equal ['gemini/g-01'], P.refs('gemma', 'red')
assert_raises(RuntimeError) { P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01') }
end
# --- Fase 13: renombrar
def test_renombrar_actualiza_registro_y_pools
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('peggy', 'red', 'gemini', 'g-01')
R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno')
assert P.renombrar_key(provider: 'gemini', de: 'g-01', a: 'g-uno')
assert_equal ['gemini/g-uno'], P.refs('gemma', 'mente')
assert_equal ['gemini/g-uno'], P.refs('peggy', 'red')
assert R.todas.any? { |k| k['identificador'] == 'g-uno' }
end
def test_renombrar_rechaza_invalido_existente_y_reservada
assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'G 01') }
assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-red') }
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
e = assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno') }
assert_match(/reservada por gemma/, e.message)
end
end
-102
View File
@@ -1,102 +0,0 @@
# frozen_string_literal: true
# revertir_test.rb — Revertir el 'agotada' propio y estado del pool por key (P334/Fase 4, integrado en P335/Fase 6).
# Corre sobre una COPIA de organismo/ en un directorio temporal: nunca el registro real.
# ruby servicios/nexxa/test/revertir_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
DIR_REVERTIR = Dir.mktmpdir('nexxa-revertir')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_REVERTIR) }
require File.join(DIR_REVERTIR, 'lib_registro')
Minitest.after_run { FileUtils.rm_rf(DIR_REVERTIR) }
class RevertirTest < Minitest::Test
R = Nexxa::Registro
def setup
FileUtils.rm_f([R::STATE_FILE, Nexxa::Usos::LOG_FILE])
pasado = (Time.now - 3600).iso8601(3)
R.guardar('keys' => %w[g-01 g-02 g-03].map { |i| { 'provider' => 'gemini', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'reservado_por' => nil, 'valor_cifrado' => 'x' } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado, 'valor_cifrado' => 'x' },
{ 'provider' => 'gemini', 'identificador' => 'g-meta', 'disponible_desde' => pasado }])
end
def test_quien_la_agoto_puede_deshacerlo_aunque_ya_no_la_tenga_reservada
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada')
assert_equal 'agotada', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' }['estado']
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'liberada')
e = R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' }
assert_equal 'disponible', e['estado']
assert_includes File.read(Nexxa::Usos::LOG_FILE), 'revertida'
end
def test_otro_individuo_no_puede_liberar_lo_que_agoto_otro
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada')
assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'peggy-f1', estado: 'liberada') }
end
def test_el_flujo_original_de_reserva_sigue_igual
R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1')
assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'otro', estado: 'sana') }
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'liberada')
assert_equal 'disponible', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-02' }['estado']
end
# Taxonomía cerrada (P337/Fase 1): un bloqueo de 60 s es una PAUSA por límite, uno largo es AGOTADA; sin valor y
# desactivada se distinguen; campos uniformes hasta/por/motivo
def test_estado_del_pool_sin_valores_y_con_la_taxonomia_completa
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429')
R.reservar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1', estado: 'agotada', motivo: 'cuota diaria')
est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] }
assert_equal %w[en_uso en_pausa agotada desactivada sin_valor], %w[g-01 g-02 g-03 g-off g-meta].map { |i| est[i]['estado'] }
assert_equal %w[gemma-f1 429], est['g-02'].values_at('por', 'motivo')
assert_operator Time.parse(est['g-02']['hasta']), :>, Time.now
assert_equal 'gemma-f1', est['g-01']['por']
refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') }
end
# Registro completo: cada paso queda con su evento, motivo y hasta
def test_el_registro_anota_cada_paso
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'sana')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429 por minuto')
R.actualizar(provider: 'gemini', identificador: 'g-03', activo: false, por: 'web:admin')
R.eliminar(provider: 'gemini', identificador: 'g-off', por: 'web:admin')
h = Nexxa::Usos.historial
assert_equal %w[baja editada pausada renovada dispensada], h.map { |u| u['evento'] }
assert_equal '429 por minuto', h[2]['motivo']
refute_nil h[2]['hasta']
assert_equal 'activo: nil → false', h[1]['motivo']
assert_equal ['web:admin'], Nexxa::Usos.historial(individuo: 'web:admin', evento: 'baja').map { |u| u['individuo'] }
end
def test_resumen_cuenta_todos_los_estados_y_los_eventos_de_la_ventana
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60)
r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24)
assert_equal R::ESTADOS.sort, r['ahora'].keys.sort, 'todos los estados, también los que están en 0'
assert_equal 1, r['ahora']['en_pausa']
assert_equal 0, r['ahora']['en_uso']
assert_equal({ 'dispensada' => 1, 'pausada' => 1 }, r['eventos'].select { |_, n| n.positive? })
g01 = r['por_key'].find { |k| k['identificador'] == 'g-01' }
assert_equal 'pausada', g01['ultimo_evento']['evento']
refute r['por_key'].any? { |k| k.key?('valor_cifrado') }
end
# Un 'agotada' anterior a 2.0.0 (sin hasta) no infla los agotamientos de cuota: se cuenta aparte, con su texto
def test_un_agotada_previo_a_2_0_0_se_cuenta_aparte
Nexxa::Usos.registrar(provider: 'gemini', identificador: 'g-01', individuo: 'x', evento: 'agotada')
r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24)
assert_equal 0, r['eventos']['agotada']
assert_equal 1, r['eventos']['agotada-previa']
u = Nexxa::Usos.historial.first
assert_equal 'agotada-previa', u['clase']
assert_match(/anterior a 2\.0\.0/, u['texto'])
end
end
-16
View File
@@ -1,16 +0,0 @@
# frozen_string_literal: true
# servidor_prueba.rb — Deja corriendo un NEXXA de PRUEBA (copia aislada, estado falso) para mirar nexxa-web en un
# navegador real (P335/Fase 7). Ctrl+C lo detiene y borra la copia.
# ruby servicios/nexxa/test/servidor_prueba.rb [--puerto 14568]
# Entra con humo-admin / humo-admin-123 (o humo-oper / humo-oper-123): usuarios INVENTADOS de la copia, no del nodo.
require_relative 'lib_servidor_prueba'
puerto = ARGV[ARGV.index('--puerto') + 1].to_i if ARGV.include?('--puerto')
prueba = ServidorPrueba.armar(individuos: %w[gemma-prueba peggy-prueba], puerto: puerto)
pid = ServidorPrueba.arrancar(prueba)
puts "NEXXA de prueba en http://127.0.0.1:#{prueba[:puerto]}/ (pid #{pid}) — usuarios: #{ServidorPrueba::USUARIOS.keys.join(', ')}"
$stdout.flush
trap('INT') { ServidorPrueba.detener(pid, prueba); exit }
trap('TERM') { ServidorPrueba.detener(pid, prueba); exit }
Process.wait(pid)
@@ -1,46 +0,0 @@
{
"nombre": "Pools: editar con casillas, guardar y mover entre mente y red",
"acciones": [
{
"tipo": "click",
"selector": "button[data-section=pools]"
},
{
"tipo": "esperar_selector",
"selector": ".pool-card"
},
{
"tipo": "js",
"retorna": true,
"codigo": "document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]').querySelector('[data-action=pool-editar]').click(); return 'editor'"
},
{
"tipo": "esperar",
"segundos": 0.5
},
{
"tipo": "js",
"retorna": true,
"codigo": "var c=document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]'); ['gemini/g-01','gemini/g-02','deepseek/d-01'].forEach(function(v){c.querySelector('input[value=\"'+v+'\"]').checked=true}); c.querySelector('[data-action=pool-guardar]').click(); return 'guardado'"
},
{
"tipo": "esperar",
"segundos": 1.5
},
{
"tipo": "js",
"retorna": true,
"codigo": "document.querySelector('.pool-card[data-individuo=gemma-prueba] .pool-col[data-rol=mente]').querySelector('.pool-key[data-identificador=d-01] [data-action=pool-mover]').click(); return 'movida'"
},
{
"tipo": "esperar",
"segundos": 1.5
},
{
"tipo": "js",
"retorna": true,
"espera": "^mente: g-01,g-02 \\| red: d-01$",
"codigo": "return Array.from(document.querySelectorAll('.pool-card[data-individuo=gemma-prueba] .pool-col')).map(function(c){return c.dataset.rol+': '+Array.from(c.querySelectorAll('.pool-key')).map(function(k){return k.dataset.identificador}).join(',')}).join(' | ')"
}
]
}
@@ -1,47 +0,0 @@
{
"nombre": "APIs con chips de pools, alta con pool, Individuos con resumen y Dashboard",
"acciones": [
{
"tipo": "click",
"selector": "button[data-section=apis]"
},
{
"tipo": "esperar",
"segundos": 1
},
{
"tipo": "js",
"retorna": true,
"espera": "^[1-9]\\d* chips; [1-9]\\d* opciones$",
"codigo": "return document.querySelectorAll('#groups .pool-chip').length + ' chips; ' + document.getElementById('f-pool').options.length + ' opciones'"
},
{
"tipo": "click",
"selector": "button[data-section=nodos]"
},
{
"tipo": "esperar",
"segundos": 1
},
{
"tipo": "js",
"retorna": true,
"espera": "gemma-prueba: .*Mente 2/2 disponibles.*Red 1/1",
"codigo": "return Array.from(document.querySelectorAll('.consumidor-card[data-individuo]')).map(function(c){return c.dataset.individuo+': '+c.querySelector('.meta').textContent}).join(' || ')"
},
{
"tipo": "click",
"selector": "button[data-section=dashboard]"
},
{
"tipo": "esperar",
"segundos": 0.5
},
{
"tipo": "js",
"retorna": true,
"espera": "^0$",
"codigo": "return document.getElementById('stat-mente-agotada').textContent"
}
]
}
@@ -1,36 +0,0 @@
{
"nombre": "Renombrar una key desde APIs: el pool la sigue",
"acciones": [
{
"tipo": "click",
"selector": "button[data-section=apis]"
},
{
"tipo": "esperar_selector",
"selector": ".key-card[data-identificador=d-01] [data-action=edit]"
},
{
"tipo": "click",
"selector": ".key-card[data-identificador=d-01] [data-action=edit]"
},
{
"tipo": "esperar_selector",
"selector": ".ep-identificador"
},
{
"tipo": "js",
"retorna": true,
"codigo": "document.querySelector('.ep-identificador').value='deepseek-uno'; document.querySelector('[data-action=save-edit]').click(); return 'guardado'"
},
{
"tipo": "esperar",
"segundos": 1.5
},
{
"tipo": "js",
"retorna": true,
"espera": "gemma-prueba · red",
"codigo": "var k=document.querySelector('.key-card[data-identificador=deepseek-uno]'); return k ? Array.from(k.querySelectorAll('.pool-chip')).map(function(c){return c.textContent}).join(',') : 'no aparece'"
}
]
}
@@ -1,70 +0,0 @@
{
"nombre": "Dashboard con estados AHORA y últimas 24 h, Por key y Registro filtrable (P337/Fase 2), solo lectura",
"produccion": true,
"acciones": [
{
"tipo": "click",
"selector": "button[data-section=dashboard]"
},
{
"tipo": "esperar",
"segundos": 2
},
{
"tipo": "js",
"retorna": true,
"espera": "^6 estados con [1-9]\\d* keys; [45] contadores 24 h$",
"codigo": "var s=document.querySelectorAll('#stats-ahora .stat'); var n=0; s.forEach(function(x){n+=parseInt(x.querySelector('.stat-value').textContent,10)}); return s.length+' estados con '+n+' keys; '+document.querySelectorAll('#stats-24h .stat').length+' contadores 24 h'"
},
{
"tipo": "js",
"retorna": true,
"espera": "^por key [1-9]\\d*$",
"codigo": "return 'por key '+document.querySelectorAll('#por-key tbody tr').length"
},
{
"tipo": "js",
"retorna": true,
"espera": "^textos ok$",
"codigo": "var crudos=Array.prototype.filter.call(document.querySelectorAll('#actividad-lista tbody td:nth-child(3)'),function(x){return /\\s(dispensada|liberada|pausada|renovada|agotada)$/.test(x.textContent)}); return crudos.length?'crudos: '+crudos[0].textContent:'textos ok'"
},
{
"tipo": "captura",
"destino": "/home/rmonla/Documentos/GitHub/dtic-GEMMA/_temp/p337/ui_dashboard.png"
},
{
"tipo": "click",
"selector": "[data-ir-registro]"
},
{
"tipo": "esperar",
"segundos": 2
},
{
"tipo": "js",
"retorna": true,
"espera": "^Registro: [1-9]\\d* fila\\(s\\)$",
"codigo": "return document.getElementById('page-title').textContent+': '+document.querySelectorAll('#registro-lista tbody tr').length+' fila(s)'"
},
{
"tipo": "captura",
"destino": "/home/rmonla/Documentos/GitHub/dtic-GEMMA/_temp/p337/ui_registro.png"
},
{
"tipo": "js",
"retorna": true,
"espera": "^filtro [a-z-]+$",
"codigo": "var t=document.querySelector('#registro-lista tbody tr td:nth-child(3)').textContent; var sel=document.getElementById('reg-evento'); var o=Array.prototype.find.call(sel.options,function(x){return x.text===t}); sel.value=o.value; sel.dispatchEvent(new Event('change')); return 'filtro '+o.value"
},
{
"tipo": "esperar",
"segundos": 2
},
{
"tipo": "js",
"retorna": true,
"espera": "^filtrado [1-9]\\d* todas iguales$",
"codigo": "var c=Array.prototype.map.call(document.querySelectorAll('#registro-lista tbody tr td:nth-child(3)'),function(x){return x.textContent}); return 'filtrado '+c.length+(c.every(function(x){return x===c[0]})?' todas iguales':' mezcladas')"
}
]
}
@@ -1,36 +0,0 @@
{
"nombre": "Producción, solo lectura: versión, pools, resumen de individuos y editor (sin guardar)",
"produccion": true,
"acciones": [
{
"tipo": "esperar",
"segundos": 1.5
},
{
"tipo": "js",
"retorna": true,
"espera": "^v\\d+\\.\\d+\\.\\d+$",
"codigo": "return document.getElementById('version-tag').textContent"
},
{
"tipo": "click",
"selector": "button[data-section=pools]"
},
{
"tipo": "esperar_selector",
"selector": ".pool-card"
},
{
"tipo": "js",
"retorna": true,
"espera": "^[1-9]\\d* individuos, [1-9]\\d* keys$",
"codigo": "return document.querySelectorAll('.pool-card').length + ' individuos, ' + document.querySelectorAll('.pool-key').length + ' keys'"
},
{
"tipo": "js",
"retorna": true,
"espera": "^editor [1-9]",
"codigo": "var c=document.querySelector('.pool-card .pool-col[data-rol=mente]'); c.querySelector('[data-action=pool-editar]').click(); var n=document.querySelectorAll('.pool-editor input').length; document.querySelector('[data-action=pool-cancelar]').click(); return 'editor ' + n"
}
]
}
File diff suppressed because it is too large Load Diff
-310
View File
@@ -1,310 +0,0 @@
<!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="registro"><span class="nav-icon">📜</span><span class="nav-label">Registro</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">
<!-- P337/Fase 2: todo lo que se ve acá lo calcula el servidor (/resumen, /usos); el navegador no reinterpreta -->
<div class="stats-titulo">Ahora <span class="stats-sub">estado de cada key</span></div>
<div class="stats" id="stats-ahora"></div>
<div class="stats-titulo">Últimas 24 h <span class="stats-sub">qué pasó con las keys</span></div>
<div class="stats" id="stats-24h"></div>
<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">Consumidores</div>
<div class="stat-value mono" id="stat-consumidores">—</div>
</div>
<div class="stat">
<div class="stat-label">Mentes sin keys</div>
<div class="stat-value warn mono" id="stat-mente-agotada">—</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">Entregas 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">Por key (últimas 24 h)</div>
<div id="por-key"></div>
</div>
<div class="panel panel-tall">
<div class="panel-title">Últimos eventos <a href="#" class="panel-link" data-ir-registro>ver registro completo →</a></div>
<div id="actividad-lista"></div>
</div>
</div>
</section>
<section id="section-apis" class="section">
<div class="notice">
<span>🔒</span>
<span><strong>Solo metadata.</strong> Esta vista nunca muestra el valor de una key — ni completo, ni parcial. El valor real solo se entrega a un individuo autenticado vía <span class="mono">GET /disponible/&lt;provider|mente|red&gt;</span>.</span>
</div>
<div id="load-error" class="notice error"></div>
<div class="error-banner" id="add-key-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo registrar la key</span>
<span class="body" id="add-key-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-key-trigger">
<span class="add-plus">+</span> Nueva key
</button>
<div class="key-card inline-add-form" id="add-key-form">
<div class="inline-add-row">
<div class="inline-add-field">
<label for="f-provider">Provider</label>
<input id="f-provider" class="mono" type="text" value="gemini" autocomplete="off" list="providers-conocidos" />
<datalist id="providers-conocidos"></datalist>
</div>
<div class="inline-add-field" id="field-identificador">
<label for="f-identificador">Identificador</label>
<input id="f-identificador" class="mono" type="text" placeholder="gemini-03" autocomplete="off" />
<span class="hint hint-conditional" id="hint-id-required">Obligatorio.</span>
<span class="hint hint-conditional" id="hint-id-taken">Ya existe.</span>
</div>
<div class="inline-add-field" id="field-cuenta-origen">
<label for="f-cuenta-origen">Cuenta de origen</label>
<input id="f-cuenta-origen" class="mono" type="text" placeholder="cuenta ante el proveedor" autocomplete="off" list="cuentas-origen-conocidas" />
<datalist id="cuentas-origen-conocidas"></datalist>
<span class="hint hint-conditional" id="hint-cuenta-required">Obligatorio.</span>
</div>
<div class="inline-add-field">
<label for="f-reset">Estimación de reset (respaldo)</label>
<select id="f-reset" class="mono">
<option value="86400">24 horas</option>
<option value="3600">1 hora</option>
<option value="604800">7 días</option>
</select>
</div>
<div class="inline-add-field">
<label for="f-pool">Asignar a pool (opcional)</label>
<select id="f-pool" class="mono"><option value="">— ninguno —</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>
<!-- P337/Fase 2: registro completo de lo que pasa con las keys, filtrado en el servidor (/usos) -->
<section id="section-registro" class="section">
<div class="registro-filtros">
<label>Ventana
<select id="reg-horas">
<option value="1">última hora</option>
<option value="24" selected>últimas 24 h</option>
<option value="168">últimos 7 días</option>
<option value="720">últimos 30 días</option>
</select>
</label>
<label>Qué pasó <select id="reg-evento"><option value="">todo</option></select></label>
<label>Key <select id="reg-key"><option value="">todas</option></select></label>
<label>Quién <input id="reg-individuo" type="text" placeholder="ej. gemma o web:admin" autocomplete="off"></label>
<span class="registro-cuenta mono" id="reg-cuenta"></span>
</div>
<div id="registro-lista"></div>
</section>
<section id="section-pools" class="section">
<div class="notice">
<span>🧩</span>
<span><strong>Pools por individuo (P335).</strong> Cada individuo piensa y opera con las keys de su pool <b>Mente</b> y usa las de su pool <b>Red</b> solo para avisar que se quedó sin batería. Un pool puede mezclar proveedores y una key puede estar en varios pools. El individuo las pide con <span class="mono">GET /disponible/mente</span> o <span class="mono">/disponible/red</span>; con un pool vacío NEXXA responde <span class="mono">pool_vacio</span>, nunca cae a otra key.</span>
</div>
<div class="notice error" id="pools-error"></div>
<div id="pools-lista"></div>
</section>
<section id="section-nodos" class="section">
<div class="notice">
<span>🔑</span>
<span><strong>Individuos con acceso.</strong> Cada uno tiene un token propio para pedir keys vía <span class="mono">GET /disponible/&lt;provider|mente|red&gt;</span>. El token se muestra en claro una única vez, al generarlo — nunca se vuelve a mostrar después.</span>
</div>
<div class="notice">
<span>📡</span>
<span><strong>Check-in proactivo (P216).</strong> Cada individuo reporta su propio estado — nunca deducido. El badge de abajo de cada tarjeta refleja el último reporte real, o "sin check-in" si el individuo todavía no adoptó el mecanismo.</span>
</div>
<div class="confirm-banner token-banner" id="token-banner">
<span>🔑</span>
<span>
<span class="title" id="token-banner-title"></span>
<span class="body">
<span class="mono token-value" id="token-banner-value"></span>
<button type="button" class="action-btn primary" id="token-copy-btn">Copiar</button>
</span>
<span class="body">Guardalo ahora (ej. en candados) — no se vuelve a mostrar en esta pantalla.</span>
</span>
</div>
<div class="error-banner" id="consumidores-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo completar la operación</span>
<span class="body" id="consumidores-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-consumidor-trigger">
<span class="add-plus">+</span> Nuevo consumidor
</button>
<div class="consumidor-card inline-add-form" id="add-consumidor-form">
<div class="inline-add-row" style="grid-template-columns: 1fr auto;">
<div class="inline-add-field" id="field-nuevo-individuo">
<label for="f-nuevo-individuo">Individuo</label>
<input id="f-nuevo-individuo" class="mono" type="text" placeholder="abby" autocomplete="off" />
<span class="hint hint-conditional" id="hint-individuo-required">Obligatorio.</span>
</div>
<div class="card-icon-actions">
<button type="button" class="icon-btn primary" data-action="save-new-consumidor" title="Generar token">💾</button>
<button type="button" class="icon-btn" data-action="cancel-new-consumidor" title="Cancelar">✕</button>
</div>
</div>
<p class="inline-add-hint">🛈 Si el individuo ya tenía token, esto lo reemplaza (rotación) — el viejo deja de servir.</p>
</div>
<div id="consumidores-list"></div>
</section>
<section id="section-usuarios" class="section">
<div class="notice">
<span>👤</span>
<span><strong>Gestión de usuarios.</strong> Solo perfil <span class="mono">admin</span> puede crear, editar o eliminar usuarios del panel. El último admin activo no se puede degradar ni eliminar.</span>
</div>
<div class="error-banner" id="usuarios-error-banner">
<span>⚠️</span>
<span>
<span class="title">No se pudo completar la operación</span>
<span class="body" id="usuarios-error-title"></span>
</span>
</div>
<button type="button" class="add-trigger" id="add-usuario-trigger">
<span class="add-plus">+</span> Nuevo usuario
</button>
<div class="key-card inline-add-form" id="add-usuario-form">
<div class="inline-add-row">
<div class="inline-add-field" id="field-nuevo-usuario">
<label for="f-nuevo-usuario">Usuario</label>
<input id="f-nuevo-usuario" class="mono" type="text" placeholder="rmonla" autocomplete="off" />
<span class="hint hint-conditional" id="hint-usuario-required">Obligatorio.</span>
</div>
<div class="inline-add-field">
<label for="f-nuevo-perfil">Perfil</label>
<select id="f-nuevo-perfil" class="mono">
<option value="operador">operador</option>
<option value="admin">admin</option>
</select>
</div>
<div class="inline-add-field secret-field" id="field-nuevo-usuario-password">
<label for="f-nuevo-usuario-password">Password inicial</label>
<input id="f-nuevo-usuario-password" type="password" placeholder="Password" autocomplete="off" />
<button type="button" class="secret-toggle" id="toggle-nuevo-usuario-password">mostrar</button>
<span class="hint hint-conditional" id="hint-usuario-password-required">Obligatorio.</span>
</div>
<div class="card-icon-actions">
<button type="button" class="icon-btn primary" data-action="save-new-usuario" title="Crear">💾</button>
<button type="button" class="icon-btn" data-action="cancel-new-usuario" title="Cancelar">✕</button>
</div>
</div>
<p class="inline-add-hint">🛈 El usuario nuevo cambia su password desde acá mismo (editar) cuando quiera — no hay auto-reset.</p>
</div>
<div id="usuarios-list"></div>
</section>
</main>
</div>
<div class="modal-backdrop" id="delete-modal-backdrop">
<div class="modal" role="alertdialog" aria-modal="true" aria-labelledby="delete-modal-title">
<div class="modal-icon">⚠️</div>
<h3 id="delete-modal-title">Eliminar key</h3>
<p class="modal-body" id="delete-modal-body"></p>
<div class="modal-field">
<label for="delete-modal-input" id="delete-modal-label"></label>
<input type="text" id="delete-modal-input" class="mono" autocomplete="off" />
</div>
<div class="modal-actions">
<button type="button" class="action-btn" id="delete-modal-cancel">Cancelar</button>
<button type="button" class="action-btn confirm" id="delete-modal-confirm" disabled>Sí, eliminar</button>
</div>
</div>
</div>
<script src="/js/app.js"></script>
</body>
</html>
File diff suppressed because it is too large Load Diff
-43
View File
@@ -1,43 +0,0 @@
(function () {
"use strict";
var form = document.getElementById("login-form");
var usuarioInput = document.getElementById("f-usuario");
var passwordInput = document.getElementById("f-password");
var submitBtn = document.getElementById("login-submit");
var errorEl = document.getElementById("login-error");
var versionEl = document.getElementById("version-tag");
if (versionEl) {
fetch("/version")
.then(function (r) { return r.json(); })
.then(function (d) { versionEl.textContent = "v" + d.version; })
.catch(function () {});
}
form.addEventListener("submit", function (e) {
e.preventDefault();
errorEl.classList.remove("visible");
submitBtn.disabled = true;
fetch("/login", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ usuario: usuarioInput.value, password: passwordInput.value })
})
.then(function (r) {
return r.json().then(function (data) { return { ok: r.ok, data: data }; });
})
.then(function (result) {
if (!result.ok) throw new Error(result.data.error || "Usuario o password incorrectos");
location.reload();
})
.catch(function (err) {
errorEl.textContent = err.message;
errorEl.classList.add("visible");
passwordInput.value = "";
passwordInput.focus();
submitBtn.disabled = false;
});
});
})();
-108
View File
@@ -1,108 +0,0 @@
<!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>