bluesurf-mcp 0.1.0__tar.gz

bluesurf_mcp-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+.dev
+
+# Secretos / credenciales (crítico: este proyecto maneja auth y cookies de Surf)
+.env
+.env.*
+*.env
+secrets.*
+*.secret
+cookies.txt
+*.cookies
+session.json
+credentials.json
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Entornos virtuales
+.venv/
+venv/
+env/
+
+# Tests / herramientas
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# IDE
+.vscode/
+.idea/
+
+# OS (Windows)
+Thumbs.db
+Desktop.ini

bluesurf_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BluePeople
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bluesurf_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: bluesurf-mcp
+Version: 0.1.0
+Summary: Servidor MCP local de solo lectura para leer tickets de BlueSurf
+Author: BluePeople
+License: MIT License
+        
+        Copyright (c) 2026 BluePeople
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: bluesurf,mcp,tickets
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: keyring>=25
+Requires-Dist: mcp>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: python-dotenv>=1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# bluesurf-mcp
+
+Servidor MCP local de **solo lectura** para que Claude u otros agentes IA lean
+tickets de **BlueSurf**. Un solo paquete PyPI incluye el núcleo
+(`bluesurf_client`) y el adaptador MCP (`bluesurf_mcp`).
+
+**Solo lectura por diseño:** no hay operaciones de escritura.
+
+## Instalación
+
+```bash
+pip install bluesurf-mcp
+```
+
+En este monorepo, modo editable:
+
+```bash
+pip install -e ./bluesurf-mcp
+```
+
+## Guardar credenciales (`login` / `logout`)
+
+La contraseña no tiene que ir en `mcp.json`. Una vez, en una terminal:
+
+```bash
+bluesurf-mcp login
+```
+
+Pide usuario y contraseña, valida contra BlueSurf y guarda la contraseña en el
+almacén del sistema (Credential Manager en Windows, Keychain en macOS, Secret
+Service en Linux). El username queda en un JSON local, sin la contraseña.
+
+```bash
+bluesurf-mcp logout
+```
+
+borra lo guardado.
+
+## Configuración (variables de entorno)
+
+El entorno **gana** sobre lo guardado con `login`. Útil para CI o para
+sobrescribir sin tocar el almacén.
+
+Claves canónicas `BLUESURF_*`; se aceptan `SURF_*` como fallback.
+
+- `BLUESURF_BASE_URL` — URL base (opcional; default `https://surf.bluepeople.com`).
+- `BLUESURF_COOKIE` — cookie de sesión ya válida → usa `CookieAuth`.
+- `BLUESURF_USERNAME` + `BLUESURF_PASSWORD` — credenciales → usa `CredentialsAuth`.
+
+Precedencia: cookie en env → usuario/contraseña en env → `bluesurf-mcp login`.
+
+El núcleo (`bluesurf_client`) no persiste secretos.
+
+## Correr el servidor
+
+```bash
+bluesurf-mcp
+```
+
+Se comunica por **stdio** (el transporte estándar para MCP local). Sin
+argumentos no pide contraseña: usa env o las credenciales de `login`.
+
+## Registrar el MCP en un cliente
+
+### Claude Code / Cursor (`.mcp.json` o config de usuario)
+
+Tras `bluesurf-mcp login`:
+
+```json
+{
+  "mcpServers": {
+    "bluesurf": {
+      "command": "bluesurf-mcp"
+    }
+  }
+}
+```
+
+Si `bluesurf-mcp` no está en el `PATH`, usa la ruta absoluta al ejecutable del
+venv o `python -m bluesurf_mcp`.
+
+Las variables `BLUESURF_*` en `env` siguen siendo válidas como override; no hace
+falta poner la contraseña ahí.
+
+## Tools expuestas (solo lectura)
+
+- `mis_proyectos` — proyectos del usuario (id, smallCode, code, name).
+- `buscar_mis_tickets(project, include_closed=False)` — tickets asignados al usuario.
+- `obtener_ticket(code)` — detalle de un ticket por su código (p. ej. `PROJ-123`).
+
+## Usar el cliente desde Python
+
+El paquete de import del núcleo es `bluesurf_client`:
+
+```python
+from bluesurf_client import BlueSurfClient, CredentialsAuth  # o CookieAuth
+```

bluesurf_mcp-0.1.0/README.md

@@ -0,0 +1,97 @@
+# bluesurf-mcp
+
+Servidor MCP local de **solo lectura** para que Claude u otros agentes IA lean
+tickets de **BlueSurf**. Un solo paquete PyPI incluye el núcleo
+(`bluesurf_client`) y el adaptador MCP (`bluesurf_mcp`).
+
+**Solo lectura por diseño:** no hay operaciones de escritura.
+
+## Instalación
+
+```bash
+pip install bluesurf-mcp
+```
+
+En este monorepo, modo editable:
+
+```bash
+pip install -e ./bluesurf-mcp
+```
+
+## Guardar credenciales (`login` / `logout`)
+
+La contraseña no tiene que ir en `mcp.json`. Una vez, en una terminal:
+
+```bash
+bluesurf-mcp login
+```
+
+Pide usuario y contraseña, valida contra BlueSurf y guarda la contraseña en el
+almacén del sistema (Credential Manager en Windows, Keychain en macOS, Secret
+Service en Linux). El username queda en un JSON local, sin la contraseña.
+
+```bash
+bluesurf-mcp logout
+```
+
+borra lo guardado.
+
+## Configuración (variables de entorno)
+
+El entorno **gana** sobre lo guardado con `login`. Útil para CI o para
+sobrescribir sin tocar el almacén.
+
+Claves canónicas `BLUESURF_*`; se aceptan `SURF_*` como fallback.
+
+- `BLUESURF_BASE_URL` — URL base (opcional; default `https://surf.bluepeople.com`).
+- `BLUESURF_COOKIE` — cookie de sesión ya válida → usa `CookieAuth`.
+- `BLUESURF_USERNAME` + `BLUESURF_PASSWORD` — credenciales → usa `CredentialsAuth`.
+
+Precedencia: cookie en env → usuario/contraseña en env → `bluesurf-mcp login`.
+
+El núcleo (`bluesurf_client`) no persiste secretos.
+
+## Correr el servidor
+
+```bash
+bluesurf-mcp
+```
+
+Se comunica por **stdio** (el transporte estándar para MCP local). Sin
+argumentos no pide contraseña: usa env o las credenciales de `login`.
+
+## Registrar el MCP en un cliente
+
+### Claude Code / Cursor (`.mcp.json` o config de usuario)
+
+Tras `bluesurf-mcp login`:
+
+```json
+{
+  "mcpServers": {
+    "bluesurf": {
+      "command": "bluesurf-mcp"
+    }
+  }
+}
+```
+
+Si `bluesurf-mcp` no está en el `PATH`, usa la ruta absoluta al ejecutable del
+venv o `python -m bluesurf_mcp`.
+
+Las variables `BLUESURF_*` en `env` siguen siendo válidas como override; no hace
+falta poner la contraseña ahí.
+
+## Tools expuestas (solo lectura)
+
+- `mis_proyectos` — proyectos del usuario (id, smallCode, code, name).
+- `buscar_mis_tickets(project, include_closed=False)` — tickets asignados al usuario.
+- `obtener_ticket(code)` — detalle de un ticket por su código (p. ej. `PROJ-123`).
+
+## Usar el cliente desde Python
+
+El paquete de import del núcleo es `bluesurf_client`:
+
+```python
+from bluesurf_client import BlueSurfClient, CredentialsAuth  # o CookieAuth
+```

bluesurf_mcp-0.1.0/bluesurf_client/__init__.py

@@ -0,0 +1,26 @@
+"""Núcleo de solo lectura para hablar con BlueSurf.
+
+Este paquete concentra toda la lógica reutilizable: autenticación (pluggable),
+manejo de sesión/cookie, endpoints de lectura y modelos tipados. Los adaptadores
+(el servidor MCP local y una eventual CLI) se construyen encima de esto sin
+duplicar lógica.
+
+Diseño de solo lectura: aquí no se expone ninguna operación de escritura.
+"""
+
+from bluesurf_client.auth import AuthError, AuthProvider, CookieAuth, CredentialsAuth
+from bluesurf_client.constants import DEFAULT_BASE_URL
+from bluesurf_client.client import BlueSurfClient
+from bluesurf_client.models import Comment, Ticket, User
+
+__all__ = [
+    "BlueSurfClient",
+    "Ticket",
+    "Comment",
+    "User",
+    "AuthProvider",
+    "AuthError",
+    "CredentialsAuth",
+    "CookieAuth",
+    "DEFAULT_BASE_URL",
+]

bluesurf_mcp-0.1.0/bluesurf_client/auth/__init__.py

@@ -0,0 +1,15 @@
+"""Autenticación pluggable contra BlueSurf.
+
+El consumidor decide el mecanismo y entrega credenciales o cookie:
+- :class:`CredentialsAuth` — usuario/contraseña (hace login).
+- :class:`CookieAuth` — cookie de sesión ya válida.
+
+La librería no persiste credenciales ni sesión: la cookie vive solo en memoria
+durante el ciclo de vida de la instancia del cliente.
+"""
+
+from bluesurf_client.auth.base import AuthError, AuthProvider
+from bluesurf_client.auth.cookie import CookieAuth
+from bluesurf_client.auth.credentials import CredentialsAuth
+
+__all__ = ["AuthProvider", "AuthError", "CredentialsAuth", "CookieAuth"]

bluesurf_mcp-0.1.0/bluesurf_client/auth/base.py

@@ -0,0 +1,48 @@
+"""Contrato de autenticación (pluggable).
+
+Un ``AuthProvider`` sabe cómo dejar una petición HTTP autenticada contra BlueSurf.
+No asume un mecanismo concreto: una implementación puede hacer login con
+credenciales y capturar la cookie ``.AspNetCore.Identity.Application``, otra
+puede reusar una cookie exportada del navegador. El núcleo solo depende de esta
+interfaz.
+
+Notas sobre la sesión de BlueSurf:
+- La sesión viaja por cookie de ASP.NET Core Identity, no por header ``Authorization``.
+- Los flags ``samesite=lax`` y ``httponly`` solo afectan al navegador; un cliente
+  backend (httpx) puede almacenar y reenviar la cookie sin problema.
+"""
+
+from __future__ import annotations
+
+import abc
+
+import httpx
+
+
+class AuthError(RuntimeError):
+    """La autenticación falló o la sesión no pudo renovarse."""
+
+
+class AuthProvider(abc.ABC):
+    """Interfaz que provee/renueva una sesión autenticada contra BlueSurf.
+
+    Las implementaciones concretas se agregan después (login programático,
+    cookie del navegador, etc.). El contrato es intencionalmente mínimo.
+    """
+
+    @abc.abstractmethod
+    async def apply(self, client: httpx.AsyncClient) -> None:
+        """Deja ``client`` autenticado.
+
+        Típicamente instala la cookie de sesión en ``client.cookies``. Se llama
+        una vez al construir el cliente y de nuevo tras ``refresh``. Debe lanzar
+        :class:`AuthError` si no puede autenticar.
+        """
+
+    async def refresh(self, client: httpx.AsyncClient) -> None:
+        """Renueva la sesión tras un 401.
+
+        Por defecto reintenta ``apply``. Las implementaciones que necesiten
+        re-login explícito (p. ej. volver a POSTear credenciales) lo sobrescriben.
+        """
+        await self.apply(client)

bluesurf_mcp-0.1.0/bluesurf_client/auth/cookie.py

@@ -0,0 +1,40 @@
+"""Autenticación por cookie provista por el consumidor.
+
+El consumidor entrega una cookie de sesión ya válida (p. ej. extraída de una
+sesión de navegador autenticada). Esta clase la instala en el cliente httpx. No
+persiste nada y no puede renovar la sesión por sí sola: si expira, es
+responsabilidad del consumidor entregar una cookie fresca.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from bluesurf_client.auth.base import AuthError, AuthProvider
+from bluesurf_client.constants import IDENTITY_COOKIE
+
+
+class CookieAuth(AuthProvider):
+    """Usa una cookie de sesión provista por el consumidor.
+
+    Por defecto asume la cookie ``.AspNetCore.Identity.Application``; se puede
+    indicar otro nombre si hiciera falta.
+    """
+
+    def __init__(self, cookie_value: str, *, cookie_name: str = IDENTITY_COOKIE) -> None:
+        if not cookie_value:
+            raise ValueError("cookie_value es obligatorio")
+        self._cookie_value = cookie_value
+        self._cookie_name = cookie_name
+
+    async def apply(self, client: httpx.AsyncClient) -> None:
+        domain = client.base_url.host
+        client.cookies.set(
+            self._cookie_name, self._cookie_value, domain=domain, path="/"
+        )
+
+    async def refresh(self, client: httpx.AsyncClient) -> None:
+        raise AuthError(
+            "La cookie provista expiró o fue rechazada. CookieAuth no puede "
+            "renovar la sesión: entrega una cookie fresca (o usa CredentialsAuth)."
+        )

bluesurf_mcp-0.1.0/bluesurf_client/auth/credentials.py

@@ -0,0 +1,59 @@
+"""Autenticación por credenciales (usuario/contraseña).
+
+El consumidor entrega usuario y contraseña; esta clase hace el POST de login y
+deja la cookie de sesión en el cliente httpx (en memoria). **No** persiste nada
+en disco: ni credenciales ni cookie. Las credenciales se mantienen en memoria
+solo para poder re-loguear si la sesión expira (401) durante la vida de la
+instancia.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from bluesurf_client.auth.base import AuthError, AuthProvider
+from bluesurf_client.constants import IDENTITY_COOKIE, LOGIN_PATH
+
+
+class CredentialsAuth(AuthProvider):
+    """Inicia sesión con usuario/contraseña contra ``POST /api/login``.
+
+    El endpoint espera JSON ``{"email", "password"}`` (el campo es ``email``
+    aunque el valor sea un nombre de usuario). No usa CSRF/anti-forgery.
+    """
+
+    def __init__(self, username: str, password: str) -> None:
+        if not username or not password:
+            raise ValueError("username y password son obligatorios")
+        # Solo en memoria; nunca se escriben a disco.
+        self._username = username
+        self._password = password
+
+    async def apply(self, client: httpx.AsyncClient) -> None:
+        base = str(client.base_url).rstrip("/")
+        try:
+            response = await client.post(
+                LOGIN_PATH,
+                json={"email": self._username, "password": self._password},
+                headers={"Origin": base, "Referer": f"{base}/login"},
+            )
+        except httpx.HTTPError as exc:  # pragma: no cover - error de red
+            raise AuthError(f"No se pudo contactar el login de BlueSurf: {exc}") from exc
+
+        if response.status_code in (400, 401, 403):
+            raise AuthError(
+                f"Login rechazado por BlueSurf (HTTP {response.status_code}): "
+                "revisa usuario/contraseña"
+            )
+        response.raise_for_status()
+
+        # httpx captura el Set-Cookie automáticamente en client.cookies.
+        if IDENTITY_COOKIE not in client.cookies:
+            raise AuthError(
+                "El login respondió 200 pero no llegó la cookie de sesión "
+                f"'{IDENTITY_COOKIE}'"
+            )
+
+    async def refresh(self, client: httpx.AsyncClient) -> None:
+        # La cookie expiró: volvemos a loguear con las credenciales en memoria.
+        await self.apply(client)

bluesurf_mcp-0.1.0/bluesurf_client/client.py

@@ -0,0 +1,145 @@
+"""Cliente de solo lectura de BlueSurf (la fachada de alto nivel).
+
+Expone las lecturas centradas en el objetivo: los tickets (work items) asignados
+al usuario. En BlueSurf no hay un endpoint "asignados a mí"; se resuelve consultando
+el kanban de un proyecto con el filtro ``assignedTo`` puesto en el id del usuario
+actual.
+
+Ciclo de vida:
+- Construcción sin efectos: ``BlueSurfClient(base_url=...)``.
+- Autenticación explícita: ``await client.login(auth)`` (inyección por método).
+- Limpieza: ``await client.aclose()``, o usa ``async with`` que la hace sola.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from bluesurf_client.auth.base import AuthProvider
+from bluesurf_client.constants import DEFAULT_BASE_URL, IDENTITY_COOKIE
+from bluesurf_client.models import Ticket, User
+from bluesurf_client.session import BlueSurfSession
+
+_PATH_CURRENT_USER = "/api/instance/currentUser"
+_PATH_MY_PROJECTS = "/api/user/current/project"
+_PATH_KANBAN = "/api/project/{project}/kanban"
+_PATH_WORKITEM = "/api/workItem/{code}"
+
+# Body base del kanban (todos los filtros vacíos). Se rellena ``assignedTo`` con
+# el id del usuario actual para que BlueSurf filtre del lado servidor.
+_KANBAN_FILTER_TEMPLATE: dict[str, Any] = {
+    "statuses": [],
+    "tags": [],
+    "sprints": [],
+    "priorities": [],
+    "assignedTo": [],
+    "reportedBy": [],
+    "colors": [],
+    "defectsOrigins": [],
+    "tagCondition": "and",
+    "search": "",
+    "quantityPerStatus": [],
+}
+
+
+class BlueSurfClient:
+    """Fachada de solo lectura sobre la API de BlueSurf."""
+
+    def __init__(self, *, base_url: str = DEFAULT_BASE_URL) -> None:
+        self._session = BlueSurfSession(base_url=base_url)
+        self._current_user: User | None = None
+
+    async def __aenter__(self) -> "BlueSurfClient":
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self._session.aclose()
+
+    async def login(self, auth: AuthProvider) -> "BlueSurfClient":
+        """Autentica la sesión. Devuelve ``self`` para encadenar."""
+        await self._session.login(auth)
+        return self
+
+    @property
+    def authenticated(self) -> bool:
+        return self._session.authenticated
+
+    def session_cookie(self, name: str = IDENTITY_COOKIE) -> str | None:
+        """Valor de la cookie de sesión (por defecto la de ASP.NET Identity)."""
+        return self._session.cookie(name)
+
+    async def aclose(self) -> None:
+        await self._session.aclose()
+
+    async def current_user(self) -> User:
+        """El usuario autenticado. Se cachea en la instancia tras la 1ª llamada."""
+        if self._current_user is None:
+            data = await self._session.get_json(_PATH_CURRENT_USER)
+            self._current_user = User.from_current_user(data)
+        return self._current_user
+
+    async def mis_proyectos(self) -> list[dict]:
+        """Proyectos del usuario (crudo). Útil para descubrir el ``smallCode``."""
+        data = await self._session.get_json(_PATH_MY_PROJECTS)
+        return data if isinstance(data, list) else []
+
+    async def mis_tickets(
+        self, project: str, *, include_closed: bool = False
+    ) -> list[Ticket]:
+        """Tickets asignados al usuario en un proyecto.
+
+        Args:
+            project: ``smallCode`` del proyecto (p. ej. ``"PROJ"``), que es el
+                prefijo del código de los tickets (``PROJ-123``).
+            include_closed: si ``False`` (default) omite los tickets en estados
+                finales (cerrados/done); si ``True`` los incluye.
+
+        Nota: el kanban pagina por columna. Con el filtro por asignado el volumen
+        es bajo, pero si tuvieras muchísimos tickets abiertos en una sola columna
+        podrían no venir todos en una sola respuesta.
+        """
+        me = await self.current_user()
+
+        body = dict(_KANBAN_FILTER_TEMPLATE)
+        body["assignedTo"] = [me.id]
+
+        data = await self._session.query_json(
+            _PATH_KANBAN.format(project=project),
+            json=body,
+            params={"skipWorkItems": "false"},
+        )
+
+        tickets: list[Ticket] = []
+        for raw in _iter_work_items(data):
+            ticket = Ticket.from_json(raw)
+            # Safety: garantizamos que sean míos aunque el filtro del servidor
+            # cambiara de semántica.
+            if ticket.assignee is None or ticket.assignee.id != me.id:
+                continue
+            if not include_closed and ticket.status_is_final:
+                continue
+            tickets.append(ticket)
+        return tickets
+
+    async def obtener_ticket(self, code: str) -> Ticket:
+        """Detalle de un ticket por su código (p. ej. ``"PROJ-123"``)."""
+        data = await self._session.get_json(_PATH_WORKITEM.format(code=code))
+        return Ticket.from_json(data)
+
+
+def _iter_work_items(kanban: Any):
+    """Aplana la respuesta del kanban → work items.
+
+    Estructura: lista por tipo → ``statuses[]`` (columnas) → ``workItems[]``.
+    """
+    if not isinstance(kanban, list):
+        return
+    for branch in kanban:
+        if not isinstance(branch, dict):
+            continue
+        for status in branch.get("statuses", []):
+            if not isinstance(status, dict):
+                continue
+            for wi in status.get("workItems", []):
+                if isinstance(wi, dict):
+                    yield wi

bluesurf_mcp-0.1.0/bluesurf_client/constants.py

@@ -0,0 +1,10 @@
+"""Constantes del núcleo."""
+
+# URL base por defecto de BlueSurf. Sobrescribible al construir el cliente/auth.
+DEFAULT_BASE_URL = "https://surf.bluepeople.com"
+
+# Cookie de sesión que emite ASP.NET Core Identity al iniciar sesión.
+IDENTITY_COOKIE = ".AspNetCore.Identity.Application"
+
+# Ruta del endpoint de login (POST JSON {"email", "password"}).
+LOGIN_PATH = "/api/login"