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/middlewares/umind_scope.go

@@ -0,0 +1,80 @@
+package middlewares
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// umindScopeKey guarda en el contexto los tenants que el que llama puede ver.
+//
+//	nil               → staff, sin restricción
+//	[]uint{}          → no ve nada (fail-closed)
+//	[]uint{1, 7}      → solo esos tenants
+//
+// Es el ÚNICO lugar donde se decide el alcance: los handlers de uMind se
+// montan bajo /app/umind (staff) y /portal/umind (cliente) con distinto
+// middleware de scope, pero comparten implementación. Un bug acá es una fuga
+// de datos entre clientes, así que no se replica esta lógica en ningún lado.
+const umindScopeKey = "umind_tenant_ids"
+
+// UmindScopeStaff deja el scope sin restricción. Existe como middleware
+// explícito (en vez de "no poner nada") para que una ruta sin scope sea un
+// error visible y no un permiso implícito.
+func UmindScopeStaff(c *fiber.Ctx) error {
+	c.Locals(umindScopeKey, []uint(nil))
+	return c.Next()
+}
+
+// UmindScopePortal acota al cliente autenticado en el portal: sus tenants son
+// los de los Cliente a los que tiene acceso (uno si es cliente, varios si es
+// partner), resueltos por el mismo GetClienteIDsForPortalUser que ya autoriza
+// el resto del portal.
+func UmindScopePortal(c *fiber.Ctx) error {
+	u := PortalUserFromLocals(c)
+	if u == nil {
+		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "no autenticado"})
+	}
+	clienteIDs := models.GetClienteIDsForPortalUser(u)
+
+	tenants, err := models.GetUmindTenantsByClientes(clienteIDs)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "no se pudo resolver el alcance"})
+	}
+	// Siempre un slice no-nil, incluso vacío: nil significa "staff, sin
+	// restricción", y confundir los dos le daría acceso total a un cliente.
+	ids := make([]uint, 0, len(tenants))
+	for _, t := range tenants {
+		ids = append(ids, t.ID)
+	}
+	c.Locals(umindScopeKey, ids)
+	return c.Next()
+}
+
+// UmindScopeDe devuelve (tenants permitidos, esStaff).
+func UmindScopeDe(c *fiber.Ctx) ([]uint, bool) {
+	v := c.Locals(umindScopeKey)
+	if v == nil {
+		// Ruta sin middleware de scope: fail-closed. Mejor romper visiblemente
+		// que servir datos de todos los clientes por omisión.
+		return []uint{}, false
+	}
+	ids, ok := v.([]uint)
+	if !ok {
+		return []uint{}, false
+	}
+	return ids, ids == nil
+}
+
+// UmindPuedeVerTenant es el chequeo que hacen los handlers.
+func UmindPuedeVerTenant(c *fiber.Ctx, tenantID uint) bool {
+	ids, esStaff := UmindScopeDe(c)
+	if esStaff {
+		return true
+	}
+	for _, id := range ids {
+		if id == tenantID {
+			return true
+		}
+	}
+	return false
+}

rest/middlewares/umind_scope_test.go

@@ -0,0 +1,63 @@
+package middlewares
+
+import (
+	"testing"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/valyala/fasthttp"
+)
+
+// El aislamiento entre clientes es la única lógica nueva donde un bug
+// significa que un cliente vea los datos de otro. Estos casos cubren el
+// contrato de UmindScopeDe/UmindPuedeVerTenant sin necesidad de base de datos.
+func TestUmindPuedeVerTenant(t *testing.T) {
+	app := fiber.New()
+
+	casos := []struct {
+		nombre   string
+		scope    interface{} // lo que quedó en Locals
+		tenantID uint
+		esperado bool
+	}{
+		{"staff ve cualquier tenant", []uint(nil), 42, true},
+		{"cliente ve el suyo", []uint{7, 9}, 7, true},
+		{"cliente ve el otro suyo", []uint{7, 9}, 9, true},
+		{"cliente NO ve el de otro", []uint{7, 9}, 8, false},
+		{"cliente sin tenants no ve nada", []uint{}, 1, false},
+		{"ruta sin middleware de scope no ve nada", nil, 1, false},
+		{"scope de tipo inesperado no ve nada", "todos", 1, false},
+	}
+
+	for _, cas := range casos {
+		t.Run(cas.nombre, func(t *testing.T) {
+			c := app.AcquireCtx(&fasthttp.RequestCtx{})
+			defer app.ReleaseCtx(c)
+			if cas.scope != nil {
+				c.Locals(umindScopeKey, cas.scope)
+			}
+			if got := UmindPuedeVerTenant(c, cas.tenantID); got != cas.esperado {
+				t.Errorf("UmindPuedeVerTenant(tenant %d) = %v, esperaba %v", cas.tenantID, got, cas.esperado)
+			}
+		})
+	}
+}
+
+// Un scope nil (staff) y uno vacío (cliente sin tenants) NO deben confundirse:
+// tratar el vacío como staff le daría acceso total a un cliente sin tenants.
+func TestScopeVacioNoEsStaff(t *testing.T) {
+	app := fiber.New()
+
+	c := app.AcquireCtx(&fasthttp.RequestCtx{})
+	defer app.ReleaseCtx(c)
+	c.Locals(umindScopeKey, []uint{})
+	if _, esStaff := UmindScopeDe(c); esStaff {
+		t.Fatal("un scope vacío se está tratando como staff: un cliente sin tenants vería todo")
+	}
+
+	c2 := app.AcquireCtx(&fasthttp.RequestCtx{})
+	defer app.ReleaseCtx(c2)
+	c2.Locals(umindScopeKey, []uint(nil))
+	if _, esStaff := UmindScopeDe(c2); !esStaff {
+		t.Fatal("un scope nil debería ser staff")
+	}
+}