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
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:
co-authored by
Claude Opus 5.5
GEMMA
parent
577b5f9698
commit
d106601946
@@ -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
|
||||
@@ -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`.
|
||||
@@ -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`.
|
||||
@@ -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 +0,0 @@
|
||||
2.0.1
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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})"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -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/<provider|mente|red></span>.</span>
|
||||
</div>
|
||||
|
||||
<div id="load-error" class="notice error"></div>
|
||||
|
||||
<div class="error-banner" id="add-key-error-banner">
|
||||
<span>⚠️</span>
|
||||
<span>
|
||||
<span class="title">No se pudo registrar la key</span>
|
||||
<span class="body" id="add-key-error-title"></span>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<button type="button" class="add-trigger" id="add-key-trigger">
|
||||
<span class="add-plus">+</span> Nueva key
|
||||
</button>
|
||||
|
||||
<div class="key-card inline-add-form" id="add-key-form">
|
||||
<div class="inline-add-row">
|
||||
<div class="inline-add-field">
|
||||
<label for="f-provider">Provider</label>
|
||||
<input id="f-provider" class="mono" type="text" value="gemini" autocomplete="off" list="providers-conocidos" />
|
||||
<datalist id="providers-conocidos"></datalist>
|
||||
</div>
|
||||
<div class="inline-add-field" id="field-identificador">
|
||||
<label for="f-identificador">Identificador</label>
|
||||
<input id="f-identificador" class="mono" type="text" placeholder="gemini-03" autocomplete="off" />
|
||||
<span class="hint hint-conditional" id="hint-id-required">Obligatorio.</span>
|
||||
<span class="hint hint-conditional" id="hint-id-taken">Ya existe.</span>
|
||||
</div>
|
||||
<div class="inline-add-field" id="field-cuenta-origen">
|
||||
<label for="f-cuenta-origen">Cuenta de origen</label>
|
||||
<input id="f-cuenta-origen" class="mono" type="text" placeholder="cuenta ante el proveedor" autocomplete="off" list="cuentas-origen-conocidas" />
|
||||
<datalist id="cuentas-origen-conocidas"></datalist>
|
||||
<span class="hint hint-conditional" id="hint-cuenta-required">Obligatorio.</span>
|
||||
</div>
|
||||
<div class="inline-add-field">
|
||||
<label for="f-reset">Estimación de reset (respaldo)</label>
|
||||
<select id="f-reset" class="mono">
|
||||
<option value="86400">24 horas</option>
|
||||
<option value="3600">1 hora</option>
|
||||
<option value="604800">7 días</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="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/<provider|mente|red></span>. El token se muestra en claro una única vez, al generarlo — nunca se vuelve a mostrar después.</span>
|
||||
</div>
|
||||
|
||||
<div class="notice">
|
||||
<span>📡</span>
|
||||
<span><strong>Check-in proactivo (P216).</strong> Cada individuo reporta su propio estado — nunca deducido. El badge de abajo de cada tarjeta refleja el último reporte real, o "sin check-in" si el individuo todavía no adoptó el mecanismo.</span>
|
||||
</div>
|
||||
|
||||
<div class="confirm-banner token-banner" id="token-banner">
|
||||
<span>🔑</span>
|
||||
<span>
|
||||
<span class="title" id="token-banner-title"></span>
|
||||
<span class="body">
|
||||
<span class="mono token-value" id="token-banner-value"></span>
|
||||
<button type="button" class="action-btn primary" id="token-copy-btn">Copiar</button>
|
||||
</span>
|
||||
<span class="body">Guardalo ahora (ej. en candados) — no se vuelve a mostrar en esta pantalla.</span>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<div class="error-banner" id="consumidores-error-banner">
|
||||
<span>⚠️</span>
|
||||
<span>
|
||||
<span class="title">No se pudo completar la operación</span>
|
||||
<span class="body" id="consumidores-error-title"></span>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<button type="button" class="add-trigger" id="add-consumidor-trigger">
|
||||
<span class="add-plus">+</span> Nuevo consumidor
|
||||
</button>
|
||||
|
||||
<div class="consumidor-card inline-add-form" id="add-consumidor-form">
|
||||
<div class="inline-add-row" style="grid-template-columns: 1fr auto;">
|
||||
<div class="inline-add-field" id="field-nuevo-individuo">
|
||||
<label for="f-nuevo-individuo">Individuo</label>
|
||||
<input id="f-nuevo-individuo" class="mono" type="text" placeholder="abby" autocomplete="off" />
|
||||
<span class="hint hint-conditional" id="hint-individuo-required">Obligatorio.</span>
|
||||
</div>
|
||||
<div class="card-icon-actions">
|
||||
<button type="button" class="icon-btn primary" data-action="save-new-consumidor" title="Generar token">💾</button>
|
||||
<button type="button" class="icon-btn" data-action="cancel-new-consumidor" title="Cancelar">✕</button>
|
||||
</div>
|
||||
</div>
|
||||
<p class="inline-add-hint">🛈 Si el individuo ya tenía token, esto lo reemplaza (rotación) — el viejo deja de servir.</p>
|
||||
</div>
|
||||
|
||||
<div id="consumidores-list"></div>
|
||||
</section>
|
||||
|
||||
<section id="section-usuarios" class="section">
|
||||
<div class="notice">
|
||||
<span>👤</span>
|
||||
<span><strong>Gestión de usuarios.</strong> Solo perfil <span class="mono">admin</span> puede crear, editar o eliminar usuarios del panel. El último admin activo no se puede degradar ni eliminar.</span>
|
||||
</div>
|
||||
|
||||
<div class="error-banner" id="usuarios-error-banner">
|
||||
<span>⚠️</span>
|
||||
<span>
|
||||
<span class="title">No se pudo completar la operación</span>
|
||||
<span class="body" id="usuarios-error-title"></span>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<button type="button" class="add-trigger" id="add-usuario-trigger">
|
||||
<span class="add-plus">+</span> Nuevo usuario
|
||||
</button>
|
||||
|
||||
<div class="key-card inline-add-form" id="add-usuario-form">
|
||||
<div class="inline-add-row">
|
||||
<div class="inline-add-field" id="field-nuevo-usuario">
|
||||
<label for="f-nuevo-usuario">Usuario</label>
|
||||
<input id="f-nuevo-usuario" class="mono" type="text" placeholder="rmonla" autocomplete="off" />
|
||||
<span class="hint hint-conditional" id="hint-usuario-required">Obligatorio.</span>
|
||||
</div>
|
||||
<div class="inline-add-field">
|
||||
<label for="f-nuevo-perfil">Perfil</label>
|
||||
<select id="f-nuevo-perfil" class="mono">
|
||||
<option value="operador">operador</option>
|
||||
<option value="admin">admin</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="inline-add-field secret-field" id="field-nuevo-usuario-password">
|
||||
<label for="f-nuevo-usuario-password">Password inicial</label>
|
||||
<input id="f-nuevo-usuario-password" type="password" placeholder="Password" autocomplete="off" />
|
||||
<button type="button" class="secret-toggle" id="toggle-nuevo-usuario-password">mostrar</button>
|
||||
<span class="hint hint-conditional" id="hint-usuario-password-required">Obligatorio.</span>
|
||||
</div>
|
||||
<div class="card-icon-actions">
|
||||
<button type="button" class="icon-btn primary" data-action="save-new-usuario" title="Crear">💾</button>
|
||||
<button type="button" class="icon-btn" data-action="cancel-new-usuario" title="Cancelar">✕</button>
|
||||
</div>
|
||||
</div>
|
||||
<p class="inline-add-hint">🛈 El usuario nuevo cambia su password desde acá mismo (editar) cuando quiera — no hay auto-reset.</p>
|
||||
</div>
|
||||
|
||||
<div id="usuarios-list"></div>
|
||||
</section>
|
||||
</main>
|
||||
</div>
|
||||
|
||||
<div class="modal-backdrop" id="delete-modal-backdrop">
|
||||
<div class="modal" role="alertdialog" aria-modal="true" aria-labelledby="delete-modal-title">
|
||||
<div class="modal-icon">⚠️</div>
|
||||
<h3 id="delete-modal-title">Eliminar key</h3>
|
||||
<p class="modal-body" id="delete-modal-body"></p>
|
||||
<div class="modal-field">
|
||||
<label for="delete-modal-input" id="delete-modal-label"></label>
|
||||
<input type="text" id="delete-modal-input" class="mono" autocomplete="off" />
|
||||
</div>
|
||||
<div class="modal-actions">
|
||||
<button type="button" class="action-btn" id="delete-modal-cancel">Cancelar</button>
|
||||
<button type="button" class="action-btn confirm" id="delete-modal-confirm" disabled>Sí, eliminar</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script src="/js/app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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;
|
||||
});
|
||||
});
|
||||
})();
|
||||
@@ -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>
|
||||
Reference in New Issue
Block a user