feat(umind): el cliente administra sus agentes desde el portal

Acá es donde uMind deja de ser una herramienta interna: el cliente entra
a /portal/studio con su sesión de portal y gestiona lo suyo.

- UmindScopePortal/UmindScopeStaff es el ÚNICO punto donde se decide el
  alcance. El del cliente sale de GetClienteIDsForPortalUser, el mismo
  que ya autoriza el resto del portal. nil = staff sin restricción,
  slice vacío = no ve nada; una ruta sin scope también cae en "no ve
  nada" para que olvidarse el middleware falle visible y no abra todo.
- Un solo set de handlers montado bajo /app/umind y /portal/umind
  (RegistrarRutasUmind). Duplicarlos sería duplicar las chances de
  olvidar un chequeo.
- Guarda de acceso en TODOS los handlers, incluidos los sub-recursos que
  llegan por :id (documento, tool, canal, conexión): hay que cargarlos
  para saber de quién son, si no un cliente podría borrar el canal de
  otro adivinando el id. Responden 404, no 403: un 403 confirmaría que
  el recurso existe.
- Cierra un bug preexistente: las lecturas GET /app/umind/* no tenían
  SoloAdmin ni pasaban por MenuMiddleware, así que cualquier usuario de
  staff podía leer los tenants de todos los clientes.
- Límite de agentes por plan (409 con mensaje claro). Un tenant sin plan
  no tiene límite: cortarles de golpe sería peor que dejarlos como estaban.
- /umind/ai-configs reemplaza con alcance a /app/api/ai-config/select,
  que devolvía TODAS las configs del sistema.
- El SPA deduce por la URL si es staff o cliente (base del router,
  prefijo de API y URL de login) y oculta lo que es solo de staff.
- Test de aislamiento entre clientes: 7 casos, incluido que un scope
  vacío no se confunda con staff.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

rest/controllers/umind_scope_helpers.go

@@ -0,0 +1,140 @@
+package controllers
+
+import (
+	"fmt"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+	"github.com/sujit-baniya/fiber-boilerplate/rest/middlewares"
+)
+
+// errSinAcceso es la respuesta uniforme cuando el que llama no tiene alcance
+// sobre el recurso. Se usa 404 y no 403 a propósito: un 403 confirmaría que
+// el tenant/agente existe, y eso ya es información de otro cliente.
+func errSinAcceso(c *fiber.Ctx) error {
+	return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "no encontrado"})
+}
+
+// accesoTenant valida que el que llama pueda operar sobre ese tenant.
+func accesoTenant(c *fiber.Ctx, tenantID uint) error {
+	if tenantID == 0 || !middlewares.UmindPuedeVerTenant(c, tenantID) {
+		return errSinAcceso(c)
+	}
+	return nil
+}
+
+// accesoAgente resuelve el agente a su tenant y valida el alcance. Devuelve el
+// agente ya cargado para no volver a buscarlo en el handler.
+func accesoAgente(c *fiber.Ctx, agenteID uint) (*models.UmindAgente, error) {
+	if agenteID == 0 {
+		return nil, errSinAcceso(c)
+	}
+	agente, err := models.GetUmindAgenteByID(agenteID)
+	if err != nil {
+		return nil, errSinAcceso(c)
+	}
+	if !middlewares.UmindPuedeVerTenant(c, agente.TenantID) {
+		return nil, errSinAcceso(c)
+	}
+	return agente, nil
+}
+
+// Los sub-recursos (documento, tool, canal, conexión) llegan por :id y no
+// dicen a qué agente pertenecen: hay que cargarlos para resolver el dueño
+// antes de dejar operar sobre ellos. Sin esto, un cliente podría borrar el
+// canal de otro adivinando el id.
+
+func accesoDocumento(c *fiber.Ctx, id uint) error {
+	doc, err := models.GetUmindDocumentoByID(id)
+	if err != nil {
+		return errSinAcceso(c)
+	}
+	_, e := accesoAgente(c, doc.AgenteID)
+	return e
+}
+
+func accesoHerramienta(c *fiber.Ctx, id uint) error {
+	h, err := models.GetUmindHerramientaByID(id)
+	if err != nil {
+		return errSinAcceso(c)
+	}
+	_, e := accesoAgente(c, h.AgenteID)
+	return e
+}
+
+func accesoCanal(c *fiber.Ctx, id uint) error {
+	canal, err := models.GetUmindCanalByID(id)
+	if err != nil {
+		return errSinAcceso(c)
+	}
+	_, e := accesoAgente(c, canal.AgenteID)
+	return e
+}
+
+// verificarCupoAgentes aplica el límite de agentes del plan. Un tenant sin
+// plan asignado (los creados antes de que existieran los planes) no tiene
+// límite: cortarles el paso de golpe sería peor que dejarlos como estaban.
+func verificarCupoAgentes(c *fiber.Ctx, tenantID uint) error {
+	plan := models.GetPlanDeTenant(tenantID)
+	if plan == nil || plan.MaxAgentes <= 0 {
+		return nil
+	}
+	agentes, err := models.GetUmindAgentesByTenant(tenantID)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+	}
+	if len(agentes) >= plan.MaxAgentes {
+		return c.Status(fiber.StatusConflict).JSON(fiber.Map{
+			"error": fmt.Sprintf("Tu plan %s permite %d agente(s) y ya los estás usando. Escribinos para ampliarlo.",
+				plan.Nombre, plan.MaxAgentes),
+		})
+	}
+	return nil
+}
+
+// tenantsVisibles filtra una lista de tenants al alcance del que llama.
+func tenantsVisibles(c *fiber.Ctx, items []models.UmindTenant) []models.UmindTenant {
+	if _, esStaff := middlewares.UmindScopeDe(c); esStaff {
+		return items
+	}
+	out := make([]models.UmindTenant, 0, len(items))
+	for _, t := range items {
+		if middlewares.UmindPuedeVerTenant(c, t.ID) {
+			out = append(out, t)
+		}
+	}
+	return out
+}
+
+func accesoConexion(c *fiber.Ctx, id uint) error {
+	cx, err := models.GetUmindConexionByID(id)
+	if err != nil {
+		return errSinAcceso(c)
+	}
+	_, e := accesoAgente(c, cx.AgenteID)
+	return e
+}
+
+// GetUmindAiConfigsHandler devuelve las configs de IA que el que llama puede
+// usar: las globales del staff más las propias de sus tenants. Es el
+// reemplazo con alcance de /app/api/ai-config/select, que devolvía TODAS las
+// configs del sistema — servírselo a un cliente le mostraría las de los demás.
+func GetUmindAiConfigsHandler(c *fiber.Ctx) error {
+	tenantIDs, esStaff := middlewares.UmindScopeDe(c)
+
+	var items []models.AiConfig
+	var err error
+	if esStaff {
+		items, err = models.GetAiConfigSelect()
+	} else {
+		items, err = models.GetAiConfigSelectPorTenants(tenantIDs)
+	}
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
+	}
+	out := make([]fiber.Map, len(items))
+	for i, it := range items {
+		out[i] = fiber.Map{"ID": it.ID, "nombre": it.Nombre, "provider": it.Provider}
+	}
+	return c.JSON(fiber.Map{"items": out})
+}