# frozen_string_literal: true # lib_pools.rb — Pools de keys POR INDIVIDUO: mente y red de seguridad (P335/Fase 4, Operador 2026-10-04) # # Cada individuo tiene dos pools: MENTE (las keys con las que piensa y opera) y RED (solo para el aviso de batería # baja). Un pool MEZCLA proveedores y una key puede estar en varios pools (exclusiva o compartida). Es el TERCER eje de # una key (ME-609): `cuenta_origen` dice quién la aportó (permanente, informativo), `reservado_por` quién la tiene AHORA # (efímero) y la asignación a pools es CONFIGURACIÓN permanente que decide un admin desde nexxa-web. # # Persistencia: pools.json junto a registro.json (0600). NEXXA guarda todo su estado en JSON en su hábitat y no tiene # Postgres (REG002 R15 lo pide justificar: un individuo sin BD propia; migrarlo a BD es otra decisión). Separado de # registro.json a propósito: lo que se edita a mano desde la web (config) no se mezcla con el estado vivo de cada key. # # Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json). require 'json' require_relative 'lib_estado' module Nexxa module Pools STATE_FILE = Estado.ruta('pools') ROLES = %w[mente red].freeze module_function # Estado vía Nexxa::Estado (P335/Fase 17) def leer d = Estado.leer('pools', STATE_FILE, { 'individuos' => {} }) d['individuos'] ||= {} d end def guardar(state) Estado.guardar('pools', STATE_FILE, state) end def mutar Estado.mutar('pools', STATE_FILE, { 'individuos' => {} }) do |d| d['individuos'] ||= {} yield d end end def ref(provider, identificador) "#{provider}/#{identificador}" end # Refs del pool de un individuo para un rol. => ["gemini/abby", "deepseek/deepseek-01", ...] def refs(individuo, rol) Array(leer.dig('individuos', individuo.to_s, rol.to_s)) end # Asigna una key al pool. Idempotente. Valida rol y que la key exista en el registro (inyectable para tests). def asignar(individuo:, rol:, provider:, identificador:, existe: nil) validar!(individuo, rol) existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } } raise "Key no encontrada: #{ref(provider, identificador)}" unless existe.call(provider, identificador) pool = nil mutar do |state| pool = (state['individuos'][individuo] ||= {})[rol] ||= [] r = ref(provider, identificador) pool << r unless pool.include?(r) state end pool end # Quita una key de un pool. => true si estaba. def quitar(individuo:, rol:, provider:, identificador:) validar!(individuo, rol) quitado = nil mutar do |state| pool = state.dig('individuos', individuo, rol) quitado = pool&.delete(ref(provider, identificador)) if quitado state['individuos'][individuo].delete(rol) if pool.empty? state['individuos'].delete(individuo) if state['individuos'][individuo].empty? end state end !quitado.nil? end # Deja el pool EXACTAMENTE con estas refs (editar desde nexxa-web, P335/Fase 12). Valida todas antes de escribir: # una sola inválida y no se toca nada. Lista vacía = vaciar el pool. => refs finales def reemplazar(individuo:, rol:, refs:, existe: nil) validar!(individuo, rol) existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } } refs = Array(refs).map(&:to_s).uniq malas = refs.reject { |r| (p, i = r.split('/', 2)) && i && existe.call(p, i) } raise "Key(s) no encontrada(s): #{malas.join(', ')}" unless malas.empty? mutar do |state| roles = (state['individuos'][individuo] ||= {}) refs.empty? ? roles.delete(rol) : roles[rol] = refs state['individuos'].delete(individuo) if roles.empty? state end refs end # Pasa una key del rol 'de' al otro rol del mismo individuo, en una sola escritura. => rol destino def mover(individuo:, de:, provider:, identificador:) validar!(individuo, de) a = (ROLES - [de.to_s]).first r = ref(provider, identificador) mutar do |state| roles = state.dig('individuos', individuo) raise "#{r} no está en #{individuo}/#{de}" unless roles && Array(roles[de]).include?(r) roles[de].delete(r) roles.delete(de) if roles[de].empty? (roles[a] ||= []) << r unless Array(roles[a]).include?(r) state end a end # Al renombrar una key, sus refs en todos los pools pasan al nombre nuevo (P335/Fase 13) def renombrar_key(provider:, de:, a:) cambio = nil mutar do |state| viejo = ref(provider, de) nuevo = ref(provider, a) cambio = false state['individuos'].each_value do |roles| roles.each_value { |pool| (i = pool.index(viejo)) && (pool[i] = nuevo) && (cambio = true) } end state end cambio end # Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas). def olvidar_key(provider:, identificador:) cambio = nil mutar do |state| r = ref(provider, identificador) cambio = false state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } } state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } } state['individuos'].delete_if { |_, roles| roles.empty? } state end cambio end # Al revocar un individuo (sin token ya no puede pedir) sus pools se borran: sin referencias colgadas (P335/F12) def olvidar_individuo(individuo) borrado = nil mutar do |state| borrado = state['individuos'].delete(individuo.to_s) state end !borrado.nil? end # Resumen por rol para la sección Individuos y el Dashboard: { 'mente' => {'total'=>, 'disponibles'=>}, ... } def resumen(individuo) ROLES.to_h do |rol| filas = Nexxa::Registro.estado_en(refs(individuo, rol)) [rol, { 'total' => filas.size, 'disponibles' => filas.count { |f| f['estado'] == 'disponible' } }] end end # Pools en los que está una key. => [{ 'individuo' =>, 'rol' => }] def de_key(provider, identificador, state = leer) r = ref(provider, identificador) state['individuos'].flat_map do |ind, roles| roles.select { |_, pool| pool.include?(r) }.map { |rol, _| { 'individuo' => ind, 'rol' => rol } } end end # --- Selección por NOMBRE (P335/Fase 5): el único lugar que decide si /disponible/ es un rol o un provider. # Rol (mente|red) → el pool del individuo; si está vacío NO cae al provider (respuesta explícita 'pool_vacio'). # Otro nombre → un provider, como antes (compatibilidad con los consumidores actuales). def rol?(nombre) ROLES.include?(nombre.to_s) end def pool_vacio?(individuo, nombre) rol?(nombre) && refs(individuo, nombre).empty? end def disponible(individuo, nombre) rol?(nombre) ? Nexxa::Registro.disponible_en(refs(individuo, nombre)) : Nexxa::Registro.disponible(nombre) end # Elegir y reservar la key en UN paso atómico (P335/Fase 17): mismo criterio de candidatas que disponible. # => entrada reservada, entrada solo-metadata sin reservar (sin valor_cifrado) o nil si no hay libre. def dispensar(individuo, nombre) if rol?(nombre) Nexxa::Registro.reservar_libre(individuo: individuo, refs: refs(individuo, nombre)) else Nexxa::Registro.reservar_libre(individuo: individuo, provider: nombre) end end def proxima(individuo, nombre) rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre) end def estado(individuo, nombre) rol?(nombre) ? Nexxa::Registro.estado_en(refs(individuo, nombre)) : Nexxa::Registro.estado_pool(nombre) end # Pools completos con el estado de cada key, para nexxa-web. Nunca valores. def con_estado leer['individuos'].transform_values do |roles| roles.to_h { |rol, pool| [rol, Nexxa::Registro.estado_en(pool)] } end end def validar!(individuo, rol) raise 'Falta el individuo' if individuo.to_s.strip.empty? raise "rol inválido: #{rol} (esperado: #{ROLES.join('|')})" unless ROLES.include?(rol.to_s) end end end