@pharmadate/mcp 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nubiia (https://nubiia.es)
+
+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.

package/README.md

@@ -1,5 +1,7 @@
 # @pharmadate/mcp
 
+[![mcptry](https://mcptry.com/badge/es.pharmadatepedido/mcp)](https://mcptry.com/servers/es.pharmadatepedido/mcp)
+
 Servidor [MCP](https://modelcontextprotocol.io) de Pharmadate. Permite a un asistente de IA (Claude, ChatGPT, Cursor, VS Code...)
 consultar el catálogo, valorar y cursar pedidos y, si eres partner (TopFarma...), gestionar tus farmacias, **sobre la API v1 de
 Pharmadate** (`/api-docs`). No accede a la base de datos: toda la autorización la hace la API.
@@ -127,7 +129,8 @@ en `READ_ONLY` con `MCP_REMOTE_MODE`.
   muestran el prefijo; con `reveal_api_key: true` la key completa va en un bloque aparte con `annotations.audience: ["user"]`. **Puede quedar en el
   historial del chat**: úsalo cuando la necesites de verdad. Si no la revelas al reactivar o rotar, esa key no se muestra en ningún sitio.
 - **Límites del MCP** (por credencial, en memoria del proceso): 30 escrituras/hora, 10 `createOrder`/hora y 500 líneas por quote o pedido; en los
-  endpoints sin autenticar, 30 peticiones/minuto por IP. La API añade sus 120 peticiones/minuto.
+  endpoints sin autenticar, 30 peticiones/minuto por IP, y 20 credenciales inválidas por minuto y IP en `/mcp` (después, 429 sin llamar a la API). Los
+  contadores por IP tienen tope de tamaño. La API añade sus 120 peticiones/minuto.
 - **Pedidos:** `createOrder` es real, firme e **idempotente por `external_ref`** (obligatoria): reintentar con la misma ref y la misma cesta no duplica.
   Si se corta la llamada, el modelo debe reintentar con la **misma** ref.
 - **Auditoría:** cada llamada queda en `api_audit` con `User-Agent: pharmadate-mcp/<versión> (remote|stdio; client=<nombre>)` y la IP real.
@@ -139,6 +142,16 @@ El `code` (60 s), el access token (1 h) y el refresh token (30 días, tope de 90
 `MCP_OAUTH_SECRET` (más PKCE, cliente y caducidad); el `client_id` es la metadata del registro firmada con HMAC. **Revocar es rotar o revocar la key**:
 cada llamada se valida contra la API y un refresh con la key revocada se rechaza. Cambiar `MCP_OAUTH_SECRET` cierra todas las sesiones.
 
+**Registro abierto y phishing.** Cualquiera puede registrar un cliente (DCR) con la `redirect_uri` y el nombre que quiera y mandarte el enlace de
+`/authorize`; si pegaras tu key, el `code` iría a su dirección. Por eso la página de login:
+
+- enseña de forma destacada **«Tras conectar, volverás a: `<host>`»**;
+- trata como **de confianza** solo los callbacks de Claude (`claude.ai`, `claude.com`), ChatGPT/OpenAI (`chatgpt.com`, `chat.openai.com`, `platform.openai.com`),
+  loopback (`127.0.0.1`, `localhost`, `[::1]`, con cualquier puerto, RFC 8252) y los de `MCP_ALLOWED_REDIRECTS`;
+- con cualquier otro host sale un **aviso rojo** y una casilla obligatoria **«Reconozco esta aplicación y su dirección»**, que el servidor exige también en el `POST`;
+- el nombre que el cliente dice tener **nunca titula la página** si no es de confianza: sale como «dice llamarse X (no verificado)»;
+- recomienda usar **un token de partner dedicado al MCP**, no la key de tu integración.
+
 ## Despliegue (operador)
 
 El MCP vive en `mcp/` y se monta **dentro de la app de Elastic Beanstalk**, detrás de `MCP_ENABLED=1`. Sin esa variable no se carga ni se expone nada.
@@ -147,11 +160,12 @@ El MCP vive en `mcp/` y se monta **dentro de la app de Elastic Beanstalk**, detr
 |---|---|
 | `MCP_ENABLED=1` | Activa `POST /mcp` y las rutas OAuth |
 | `MCP_PUBLIC_URL` | URL pública, p. ej. `https://www.pharmadatepedido.es` (issuer y recurso) |
-| `MCP_OAUTH_SECRET` | 32+ caracteres aleatorios (`openssl rand -base64 48`) |
+| `MCP_OAUTH_SECRET` | Hex o base64 de **32+ bytes** aleatorios (`openssl rand -base64 48`, 64 caracteres). Uno corto o sin aleatoriedad (`xxxx…`) se rechaza y el MCP no se monta |
+| `MCP_ALLOWED_REDIRECTS` | Opcional: callbacks OAuth de confianza además de Claude, ChatGPT/OpenAI y loopback; hosts u orígenes separados por comas (`app.socio.es,https://otro.es:8443`). Sin ella, la lista extra queda vacía |
 | `MCP_ALLOWED_ORIGINS` | Opcional: orígenes de navegador extra (por defecto claude.ai, claude.com, chatgpt.com) |
 | `MCP_ALLOWED_HOSTS` | Opcional: hostnames extra para la cabecera `Host` (protección contra DNS rebinding) |
 | `MCP_REMOTE_MODE` | Opcional: `READ_ONLY` para un remoto de solo lectura |
-| `MCP_PROXY_HOPS` | Opcional: proxies de confianza delante de la app para leer `X-Forwarded-For` (**2** con ALB + nginx, por defecto; **1** en la beta) |
+| `MCP_PROXY_HOPS` | Opcional: proxies de confianza delante de la app para leer `X-Forwarded-For` (**2** con ALB + nginx, por defecto; **1** en la beta). La API v1 usa la misma cuenta (`backend/services/ipCliente.js`; también acepta `TRUSTED_PROXY_HOPS`, que manda sobre esta) |
 
 Los workflows `deploy-prod.yml`, `deploy-dev.yml` y `deploy-beta.yml` compilan el MCP (`cd mcp && npm ci && npm run build`) y meten `mcp/dist` en el zip; las
 dependencias (`@modelcontextprotocol/sdk`, `zod`, `pino`) están en `backend/package.json` porque EB solo instala las de producción. **La beta solo sirve HTTP**
@@ -179,6 +193,10 @@ Probar con el inspector: `npx @modelcontextprotocol/inspector` y la URL `http://
 
 Diseño completo y decisiones: [`docs/diseno_mcp.md`](../docs/diseno_mcp.md).
 
+## Licencia
+
+[MIT](LICENSE) © 2026 Nubiia.
+
 ## Desarrollado por
 
 Desarrollado por [Nubiia](https://nubiia.es) · Contacto: samuel.fraga@nubiia.es

package/dist/auth/crypto.d.ts

@@ -1,5 +1,13 @@
 export type TokenKind = 'code' | 'access' | 'refresh';
 export declare const MIN_SECRET_LENGTH = 32;
+/** Entropia minima del secreto, en bytes (`openssl rand -base64 48` da 48; `openssl rand -hex 32` da 32). */
+export declare const MIN_SECRET_BYTES = 32;
+/**
+ * Comprueba `MCP_OAUTH_SECRET`: tiene que ser hex o base64 y, decodificado, de al menos {@link MIN_SECRET_BYTES} bytes, con
+ * caracteres variados (un `xxxxxxxx...` de 40 letras tiene longitud de sobra y entropia cero). Devuelve el motivo del rechazo, o
+ * `null` si vale.
+ */
+export declare function secretProblem(secret: unknown): string | null;
 export interface DerivedKeys {
     enc: Buffer;
     mac: Buffer;

package/dist/auth/crypto.js

@@ -16,10 +16,37 @@
 import { createCipheriv, createDecipheriv, createHmac, hkdfSync, randomBytes, timingSafeEqual } from 'node:crypto';
 const PREFIX = { code: 'pdc1.', access: 'pda1.', refresh: 'pdr1.' };
 export const MIN_SECRET_LENGTH = 32;
-export function deriveKeys(secret) {
-    if (typeof secret !== 'string' || secret.length < MIN_SECRET_LENGTH) {
-        throw new Error(`MCP_OAUTH_SECRET debe tener al menos ${MIN_SECRET_LENGTH} caracteres.`);
+/** Entropia minima del secreto, en bytes (`openssl rand -base64 48` da 48; `openssl rand -hex 32` da 32). */
+export const MIN_SECRET_BYTES = 32;
+/**
+ * Comprueba `MCP_OAUTH_SECRET`: tiene que ser hex o base64 y, decodificado, de al menos {@link MIN_SECRET_BYTES} bytes, con
+ * caracteres variados (un `xxxxxxxx...` de 40 letras tiene longitud de sobra y entropia cero). Devuelve el motivo del rechazo, o
+ * `null` si vale.
+ */
+export function secretProblem(secret) {
+    const ayuda = ' Genera uno con `openssl rand -base64 48`.';
+    if (typeof secret !== 'string' || secret.length < MIN_SECRET_LENGTH)
+        return `MCP_OAUTH_SECRET debe tener al menos ${MIN_SECRET_LENGTH} caracteres.${ayuda}`;
+    let bytes;
+    if (/^[0-9a-fA-F]+$/.test(secret)) {
+        bytes = secret.length % 2 === 0 ? secret.length / 2 : 0;
+    }
+    else if (/^[A-Za-z0-9+/_-]+={0,2}$/.test(secret)) {
+        bytes = Buffer.from(secret, 'base64').length;
     }
+    else {
+        return `MCP_OAUTH_SECRET debe ser hex o base64 (sin espacios ni otros simbolos).${ayuda}`;
+    }
+    if (bytes < MIN_SECRET_BYTES)
+        return `MCP_OAUTH_SECRET debe equivaler a al menos ${MIN_SECRET_BYTES} bytes aleatorios una vez decodificado (hex o base64).${ayuda}`;
+    if (new Set(secret).size < 10)
+        return `MCP_OAUTH_SECRET tiene muy pocos caracteres distintos: no parece aleatorio.${ayuda}`;
+    return null;
+}
+export function deriveKeys(secret) {
+    const problema = secretProblem(secret);
+    if (problema)
+        throw new Error(problema);
     const salt = Buffer.from('pharmadate-mcp/oauth/v1');
     return {
         enc: Buffer.from(hkdfSync('sha256', secret, salt, 'enc', 32)),

package/dist/auth/login-page.d.ts

@@ -14,9 +14,18 @@ export interface LoginPageParams {
     scope?: string | undefined;
     state?: string | undefined;
     resource?: string | undefined;
+    /** Nombre que el cliente SE PONE al registrarse: no esta verificado. */
     clientName?: string | undefined;
+    /** Host al que se vuelve tras conectar (se muestra de forma destacada). */
+    redirectHost: string;
+    /** `true` si el callback es de confianza ({@link classifyRedirect}); si no, aviso rojo y casilla obligatoria. */
+    trusted: boolean;
+    /** Callback de loopback: sin aviso ni casilla, pero el nombre del cliente tampoco esta verificado. */
+    loopback?: boolean | undefined;
     errorMessage?: string | undefined;
 }
+/** Quita saltos de linea y caracteres de control del nombre autodeclarado (no puede disfrazarse de otra frase). */
+export declare function cleanClientName(nombre: string | undefined): string;
 export declare function escapeHtml(valor: string): string;
 export declare const LOGIN_PATH = "/oauth/login";
 export declare function renderLoginPage(p: LoginPageParams): string;

package/dist/auth/login-page.js

@@ -7,13 +7,32 @@
  *
  * @module auth/login-page
  */
+/** Quita saltos de linea y caracteres de control del nombre autodeclarado (no puede disfrazarse de otra frase). */
+export function cleanClientName(nombre) {
+    // eslint-disable-next-line no-control-regex
+    return (nombre ?? '').replace(/[\u0000-\u001f\u007f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g, ' ').trim().slice(0, 100);
+}
 export function escapeHtml(valor) {
     return valor.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 }
 const hidden = (name, value) => value === undefined || value === '' ? '' : `<input type="hidden" name="${name}" value="${escapeHtml(value)}">`;
 export const LOGIN_PATH = '/oauth/login';
 export function renderLoginPage(p) {
-    const cliente = escapeHtml(p.clientName || 'tu asistente de IA');
+    const nombre = cleanClientName(p.clientName);
+    const destino = escapeHtml(p.redirectHost);
+    // Un cliente de confianza puede titular la pagina con su nombre; uno que no lo es, no: el nombre lo escribe quien lo registro.
+    // Solo un destino de confianza que NO es loopback (claude.ai, chatgpt.com...) puede titular la pagina con el nombre que dice tener
+    const nombreFiable = p.trusted && !p.loopback;
+    const cliente = nombreFiable ? escapeHtml(nombre || 'tu asistente de IA') : (p.loopback ? 'una aplicación local' : 'una aplicación externa');
+    const titular = nombreFiable
+        ? ''
+        : `<p class="unverified">${nombre ? `Dice llamarse &laquo;${escapeHtml(nombre)}&raquo; <strong>(no verificado)</strong>.` : 'No ha indicado ningún nombre.'}</p>`;
+    const aviso = p.trusted
+        ? ''
+        : `<div class="warn" role="alert"><strong>Atención: esta dirección no es de un asistente de confianza.</strong> No es Claude, ni ChatGPT, ni una aplicación de tu equipo. Si sigues, quien controle <strong>${destino}</strong> podrá consultar el catálogo, cursar pedidos y, si eres partner, gestionar tus farmacias con los permisos de tu API key. Continúa solo si has iniciado tú esta conexión y reconoces la aplicación.</div>`;
+    const reconocer = p.trusted
+        ? ''
+        : `<label class="ack"><input type="checkbox" name="ack" value="1" required> Reconozco esta aplicación y su dirección (<strong>${destino}</strong>)</label>`;
     const error = p.errorMessage ? `<div class="error" role="alert">${escapeHtml(p.errorMessage)}</div>` : '';
     return `<!DOCTYPE html>
 <html lang="es">
@@ -35,6 +54,13 @@ export function renderLoginPage(p) {
   button:hover{background:#1e293b}
   .error{background:#fef2f2;color:#991b1b;border:1px solid #fecaca;border-radius:8px;padding:10px 12px;margin-bottom:16px;font-size:.88rem}
   .hint{font-size:.8rem;color:#64748b;margin-top:14px}
+  .dest{background:#f1f5f9;border:1px solid #cbd5e1;border-radius:8px;padding:10px 12px;margin-bottom:16px;font-size:.92rem;color:#0f172a;word-break:break-all}
+  .dest strong{font-size:1.02rem}
+  .warn{background:#fef2f2;color:#991b1b;border:2px solid #dc2626;border-radius:8px;padding:12px;margin-bottom:16px;font-size:.88rem;line-height:1.45}
+  .unverified{color:#991b1b;font-size:.88rem}
+  .ack{display:flex;gap:8px;align-items:flex-start;font-weight:600;font-size:.88rem;margin-top:14px;color:#991b1b}
+  .ack input{margin-top:3px}
+  .tip{background:#fffbeb;border:1px solid #fde68a;color:#78350f;border-radius:8px;padding:10px 12px;margin-top:14px;font-size:.82rem;line-height:1.45}
   .brand{font-weight:700;letter-spacing:.02em;color:#0f172a;margin-bottom:18px}
 </style>
 </head>
@@ -42,15 +68,20 @@ export function renderLoginPage(p) {
 <main>
   <div class="brand">Pharmadate</div>
   <h1>Conectar con ${cliente}</h1>
-  <p>${cliente} podra consultar el catalogo, valorar y cursar pedidos y, si eres partner, gestionar tus farmacias, con los permisos de la API key que pegues aqui.</p>
+  ${titular}
+  <div class="dest">Tras conectar, volverás a: <strong>${destino}</strong></div>
+  <p>${nombreFiable ? cliente : 'Esta aplicación'} podrá consultar el catálogo, valorar y cursar pedidos y, si eres partner, gestionar tus farmacias, con los permisos de la API key que pegues aquí.</p>
+  ${aviso}
   ${error}
   <form method="post" action="${LOGIN_PATH}" autocomplete="off">
     ${hidden('client_id', p.clientId)}${hidden('redirect_uri', p.redirectUri)}${hidden('code_challenge', p.codeChallenge)}${hidden('scope', p.scope)}${hidden('state', p.state)}${hidden('resource', p.resource)}
     <label for="api_key">API key de Pharmadate</label>
     <input id="api_key" name="api_key" type="password" required placeholder="pk_partner_... o pk_live_..." spellcheck="false" autocapitalize="off">
+    ${reconocer}
     <button type="submit">Conectar</button>
   </form>
-  <p class="hint">Consejo para partners: crea una credencial dedicada &laquo;MCP&raquo; en tu panel (/partner.html) y revocala cuando quieras. Para desconectar basta con rotar o revocar la key. Esta version solo admite keys de partner o de farmacia.</p>
+  <div class="tip"><strong>Usa un token de partner dedicado al MCP.</strong> Crea una credencial &laquo;MCP&raquo; propia en tu panel (/partner.html) y pega esa, no la que usa tu integración: así puedes revocarla en cualquier momento sin cortar nada más. Para desconectar basta con rotar o revocar la key.</div>
+  <p class="hint">Esta versión solo admite keys de partner o de farmacia.</p>
 </main>
 </body>
 </html>`;

package/dist/auth/oauth-provider.d.ts

@@ -27,6 +27,8 @@ import type { OAuthClientInformationFull, OAuthTokens } from '@modelcontextproto
 import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
 import { type DerivedKeys } from './crypto.js';
 export declare const SCOPE = "mcp:tools";
+/** Mensaje de `verifyAccessToken` con un token caducado (el servidor lo distingue de uno falsificado). */
+export declare const TOKEN_EXPIRED_MESSAGE = "Token caducado.";
 export declare const CODE_TTL_S = 60;
 export declare const ACCESS_TTL_S = 3600;
 export declare const REFRESH_TTL_S: number;
@@ -53,18 +55,23 @@ export interface OAuthProviderOptions {
     validateKey: KeyValidator;
     /** URL canonica del recurso MCP (p. ej. https://www.pharmadatepedido.es/mcp). */
     resourceUrl: URL;
+    /** Callbacks de confianza ADEMAS de los de Claude, ChatGPT/OpenAI y loopback (`MCP_ALLOWED_REDIRECTS`): hosts u origenes. */
+    trustedRedirects?: string[];
 }
 export declare class PharmadateOAuthProvider implements OAuthServerProvider {
     readonly clientsStore: StatelessClientsStore;
     private readonly keys;
     private readonly validateKey;
     readonly resourceUrl: URL;
+    private readonly extraRedirects;
     constructor(options: OAuthProviderOptions);
-    /** GET /authorize: muestra la pagina donde se pega la API key. */
+    /** GET /authorize: muestra la pagina donde se pega la API key (con el destino y, si no es de confianza, el aviso). */
     authorize(client: OAuthClientInformationFull, params: AuthorizationParams, res: Response): Promise<void>;
     /**
      * POST /oauth/login: valida la API key y, si es buena, redirige al cliente con un code.
-     * `redirect_uri` se vuelve a comprobar contra las registradas en el client_id (anti open-redirect).
+     * `redirect_uri` se vuelve a comprobar contra las registradas en el client_id (anti open-redirect), con la misma regla que
+     * `/authorize` (exacta, salvo el puerto en loopback). Si el callback no es de confianza hace falta `ack=1` (la casilla
+     * "Reconozco esta aplicacion y su direccion"): se exige AQUI, no solo en la pagina, y antes de mirar la API key.
      */
     handleLoginPost(form: {
         api_key?: string;
@@ -74,6 +81,7 @@ export declare class PharmadateOAuthProvider implements OAuthServerProvider {
         scope?: string;
         state?: string;
         resource?: string;
+        ack?: string;
     }, res: Response): Promise<void>;
     challengeForAuthorizationCode(client: OAuthClientInformationFull, authorizationCode: string): Promise<string>;
     exchangeAuthorizationCode(client: OAuthClientInformationFull, authorizationCode: string, _codeVerifier?: string, redirectUri?: string, resource?: URL): Promise<OAuthTokens>;

package/dist/auth/oauth-provider.js

@@ -1,8 +1,11 @@
 import { InvalidGrantError, InvalidTokenError, InvalidRequestError, ServerError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
 import { deriveKeys, open, seal, sign, verify } from './crypto.js';
 import { loginPageHeaders, renderLoginPage } from './login-page.js';
+import { classifyRedirect, parseExtraRedirects, redirectIsRegistered } from './redirect-trust.js';
 import { logger } from '../logger.js';
 export const SCOPE = 'mcp:tools';
+/** Mensaje de `verifyAccessToken` con un token caducado (el servidor lo distingue de uno falsificado). */
+export const TOKEN_EXPIRED_MESSAGE = 'Token caducado.';
 export const CODE_TTL_S = 60;
 export const ACCESS_TTL_S = 3_600;
 export const REFRESH_TTL_S = 30 * 24 * 3_600;
@@ -56,16 +59,22 @@ export class PharmadateOAuthProvider {
     keys;
     validateKey;
     resourceUrl;
+    extraRedirects;
     constructor(options) {
+        this.extraRedirects = parseExtraRedirects(options.trustedRedirects);
         this.keys = deriveKeys(options.secret);
         this.clientsStore = new StatelessClientsStore(this.keys);
         this.validateKey = options.validateKey;
         this.resourceUrl = options.resourceUrl;
     }
-    /** GET /authorize: muestra la pagina donde se pega la API key. */
+    /** GET /authorize: muestra la pagina donde se pega la API key (con el destino y, si no es de confianza, el aviso). */
     async authorize(client, params, res) {
+        const trust = classifyRedirect(params.redirectUri, this.extraRedirects);
         res.set(loginPageHeaders());
         res.send(renderLoginPage({
+            redirectHost: trust.display,
+            trusted: trust.trusted,
+            loopback: trust.loopback === true,
             clientId: client.client_id,
             redirectUri: params.redirectUri,
             codeChallenge: params.codeChallenge,
@@ -77,11 +86,13 @@ export class PharmadateOAuthProvider {
     }
     /**
      * POST /oauth/login: valida la API key y, si es buena, redirige al cliente con un code.
-     * `redirect_uri` se vuelve a comprobar contra las registradas en el client_id (anti open-redirect).
+     * `redirect_uri` se vuelve a comprobar contra las registradas en el client_id (anti open-redirect), con la misma regla que
+     * `/authorize` (exacta, salvo el puerto en loopback). Si el callback no es de confianza hace falta `ack=1` (la casilla
+     * "Reconozco esta aplicacion y su direccion"): se exige AQUI, no solo en la pagina, y antes de mirar la API key.
      */
     async handleLoginPost(form, res) {
         const client = typeof form.client_id === 'string' ? this.clientsStore.getClient(form.client_id) : undefined;
-        if (!client || typeof form.redirect_uri !== 'string' || !client.redirect_uris.map(String).includes(form.redirect_uri)) {
+        if (!client || typeof form.redirect_uri !== 'string' || !redirectIsRegistered(form.redirect_uri, client.redirect_uris.map(String))) {
             res.status(400).type('text/plain').send('Cliente o redirect_uri no validos.');
             return;
         }
@@ -90,9 +101,13 @@ export class PharmadateOAuthProvider {
             res.status(400).type('text/plain').send('Falta el code_challenge PKCE (S256).');
             return;
         }
+        const trust = classifyRedirect(form.redirect_uri, this.extraRedirects);
         const volver = (errorMessage) => {
             res.status(200).set(loginPageHeaders());
             res.send(renderLoginPage({
+                redirectHost: trust.display,
+                trusted: trust.trusted,
+                loopback: trust.loopback === true,
                 clientId: client.client_id,
                 redirectUri: form.redirect_uri,
                 codeChallenge: challenge,
@@ -103,6 +118,11 @@ export class PharmadateOAuthProvider {
                 errorMessage,
             }));
         };
+        if (!trust.trusted && form.ack !== '1') {
+            logger.warn({ client: client.client_name ?? 'unknown', redirect_host: trust.display }, 'oauth login sin reconocer un callback no verificado');
+            volver('Marca la casilla «Reconozco esta aplicación y su dirección» para continuar.');
+            return;
+        }
         const apiKey = typeof form.api_key === 'string' ? form.api_key.trim() : '';
         if (!apiKey || apiKey.length > 200 || /\s/.test(apiKey)) {
             volver('Pega tu API key de Pharmadate.');
@@ -128,7 +148,7 @@ export class PharmadateOAuthProvider {
         destino.searchParams.set('code', code);
         if (form.state)
             destino.searchParams.set('state', form.state);
-        logger.info({ client: client.client_name ?? 'unknown' }, 'oauth login ok');
+        logger.info({ client: client.client_name ?? 'unknown', redirect_host: trust.display, trusted: trust.trusted }, 'oauth login ok');
         res.set('Cache-Control', 'no-store').redirect(302, destino.toString());
     }
     async challengeForAuthorizationCode(client, authorizationCode) {
@@ -172,7 +192,7 @@ export class PharmadateOAuthProvider {
         if (!a)
             throw new InvalidTokenError('Token invalido.');
         if (a.exp < nowS())
-            throw new InvalidTokenError('Token caducado.');
+            throw new InvalidTokenError(TOKEN_EXPIRED_MESSAGE);
         const info = { token, clientId: a.cid, scopes: a.sc, expiresAt: a.exp, extra: { apiKey: a.k } };
         if (a.res)
             info.resource = new URL(a.res);

package/dist/auth/redirect-trust.d.ts

@@ -0,0 +1,26 @@
+/** Hosts https de los asistentes de IA que se conectan de verdad por OAuth. */
+export declare const TRUSTED_REDIRECT_HOSTS: readonly string[];
+/** Extras del operador ya interpretados. */
+export interface ExtraRedirects {
+    hosts: Set<string>;
+    origins: Set<string>;
+}
+export interface RedirectClassification {
+    /** `true` si el callback es de confianza (no hace falta que el usuario lo reconozca). */
+    trusted: boolean;
+    /** `true` si es loopback: de confianza para no exigir la casilla, pero el nombre del cliente sigue sin estar verificado. */
+    loopback?: boolean;
+    /** Lo que se ensena al usuario: el host (con puerto si no es el de por defecto). Nunca la URL completa. */
+    display: string;
+}
+/** Interpreta `MCP_ALLOWED_REDIRECTS` (hosts u origenes). Lo que no se entiende se ignora. */
+export declare function parseExtraRedirects(entries: readonly string[] | undefined): ExtraRedirects;
+/** Host que se muestra al usuario. Con esquemas que no son http(s) (`cursor://...`) se antepone el esquema. */
+export declare function displayHost(redirectUri: string): string;
+/** Clasifica una `redirect_uri` como de confianza o no. Una URL que no se puede interpretar nunca es de confianza. */
+export declare function classifyRedirect(redirectUri: string, extra?: ExtraRedirects): RedirectClassification;
+/**
+ * ¿`requested` es una de las `registered`? Igual que el SDK en `/authorize` (exacta, salvo el puerto de loopback), para que
+ * lo que acepta `/authorize` no lo rechace despues `/oauth/login`.
+ */
+export declare function redirectIsRegistered(requested: string, registered: readonly string[]): boolean;

package/dist/auth/redirect-trust.js

@@ -0,0 +1,94 @@
+/**
+ * Callbacks de confianza del OAuth del MCP.
+ *
+ * El registro dinamico de clientes (DCR) es abierto: cualquiera puede registrar un cliente con la `redirect_uri` y el
+ * `client_name` que quiera y enviarle a un usuario el enlace de `/authorize`. Si el usuario pega su API key en la pagina,
+ * el `code` acaba en la direccion del atacante (phishing). El registro no se puede cerrar (Claude y ChatGPT se registran
+ * solos), asi que la defensa es que la pagina de login distinga los callbacks conocidos de los que no, y que pida un
+ * reconocimiento explicito (checkbox, validado en el servidor) para los segundos.
+ *
+ * De confianza:
+ *   - Claude:           https://claude.ai, https://claude.com
+ *   - ChatGPT / OpenAI: https://chatgpt.com, https://chat.openai.com, https://platform.openai.com
+ *   - Loopback:         http(s)://127.0.0.1, localhost, [::1] con CUALQUIER puerto (RFC 8252 §7.3, como el SDK)
+ *   - Extra:            `MCP_ALLOWED_REDIRECTS`, lista separada por comas de hosts (`app.ejemplo.com`) o de origenes
+ *                       (`https://app.ejemplo.com:8443`). Un host a secas solo vale con https; los esquemas propios
+ *                       (`cursor://`, `vscode://`) no se pueden fiar por host y siempre piden el reconocimiento.
+ *
+ * Los hosts fijos se comparan EXACTOS (`claude.ai.evil.com` o `evil.com/claude.ai` no pasan) y sin puerto ni usuario.
+ *
+ * @module auth/redirect-trust
+ */
+import { redirectUriMatches } from '@modelcontextprotocol/sdk/server/auth/handlers/authorize.js';
+/** Hosts https de los asistentes de IA que se conectan de verdad por OAuth. */
+export const TRUSTED_REDIRECT_HOSTS = ['claude.ai', 'claude.com', 'chatgpt.com', 'chat.openai.com', 'platform.openai.com'];
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Interpreta `MCP_ALLOWED_REDIRECTS` (hosts u origenes). Lo que no se entiende se ignora. */
+export function parseExtraRedirects(entries) {
+    const extra = { hosts: new Set(), origins: new Set() };
+    for (const crudo of entries ?? []) {
+        const e = crudo.trim().toLowerCase();
+        if (!e)
+            continue;
+        if (e.includes('://')) {
+            try {
+                const u = new URL(e);
+                // Solo origenes https: el `origin` de un esquema propio (`cursor://...`) es "null" y no identifica a nadie
+                if (u.protocol === 'https:' && u.hostname && !u.username && !u.password)
+                    extra.origins.add(u.origin);
+            }
+            catch {
+                /* entrada no valida: se ignora */
+            }
+        }
+        else if (/^[a-z0-9.-]+$/.test(e) && !e.startsWith('.') && !e.endsWith('.')) {
+            extra.hosts.add(e);
+        }
+    }
+    return extra;
+}
+/** Host que se muestra al usuario. Con esquemas que no son http(s) (`cursor://...`) se antepone el esquema. */
+export function displayHost(redirectUri) {
+    try {
+        const u = new URL(redirectUri);
+        if (u.protocol === 'http:' || u.protocol === 'https:')
+            return u.host;
+        return u.host ? `${u.protocol}//${u.host}` : u.protocol;
+    }
+    catch {
+        return '(direccion no valida)';
+    }
+}
+/** Clasifica una `redirect_uri` como de confianza o no. Una URL que no se puede interpretar nunca es de confianza. */
+export function classifyRedirect(redirectUri, extra = { hosts: new Set(), origins: new Set() }) {
+    const display = displayHost(redirectUri);
+    let u;
+    try {
+        u = new URL(redirectUri);
+    }
+    catch {
+        return { trusted: false, display };
+    }
+    if (u.username || u.password)
+        return { trusted: false, display };
+    const host = u.hostname.toLowerCase();
+    // Loopback: cualquier puerto, http o https
+    if ((u.protocol === 'http:' || u.protocol === 'https:') && LOOPBACK_HOSTS.has(host))
+        return { trusted: true, loopback: true, display };
+    if (u.protocol !== 'https:')
+        return { trusted: false, display };
+    if (u.port === '' && TRUSTED_REDIRECT_HOSTS.includes(host))
+        return { trusted: true, display };
+    if (extra.origins.has(u.origin.toLowerCase()))
+        return { trusted: true, display };
+    if (u.port === '' && extra.hosts.has(host))
+        return { trusted: true, display };
+    return { trusted: false, display };
+}
+/**
+ * ¿`requested` es una de las `registered`? Igual que el SDK en `/authorize` (exacta, salvo el puerto de loopback), para que
+ * lo que acepta `/authorize` no lo rechace despues `/oauth/login`.
+ */
+export function redirectIsRegistered(requested, registered) {
+    return registered.some((r) => redirectUriMatches(requested, String(r)));
+}

package/dist/http.d.ts

@@ -22,6 +22,8 @@
 import { Router, type Request } from 'express';
 import { McpLimits } from './limits.js';
 import { type OperationMode } from './config.js';
+/** Credenciales invalidas por minuto y IP a partir de las cuales se bloquean las keys `pk_` crudas sin validar (IPs de egress compartidas: umbral holgado). */
+export declare const DEFAULT_INVALID_BEARER_PER_MIN = 200;
 /** Origenes de navegador admitidos por defecto (los clientes MCP nativos no mandan `Origin`). */
 export declare const DEFAULT_ALLOWED_ORIGINS: string[];
 export interface McpRouterOptions {
@@ -40,11 +42,20 @@ export interface McpRouterOptions {
     /** Modo de operacion del transporte remoto. Por defecto STANDARD. */
     mode?: OperationMode;
     limits?: McpLimits;
-    /** Peticiones por minuto y por IP en los endpoints sin autenticar. Por defecto 30 (OAuth y 401) y 10 (login). */
+    /**
+     * Callbacks de confianza ADEMAS de los de Claude, ChatGPT/OpenAI y loopback (`MCP_ALLOWED_REDIRECTS`): hosts (`app.ejemplo.com`) u
+     * origenes (`https://app.ejemplo.com:8443`). Cualquier otro callback sale con aviso rojo y casilla obligatoria en el login.
+     */
+    trustedRedirects?: string[];
+    /**
+     * Peticiones por minuto y por IP en los endpoints sin autenticar. Por defecto 30 (OAuth y 401 sin credencial), 10 (login) y
+     * 200 (`invalidBearer`: credenciales invalidas; pasado el limite, las keys `pk_` crudas no validadas reciben 429 SIN llamar a la API; los tokens OAuth validos nunca se bloquean).
+     */
     ipRateLimits?: {
         oauth?: number;
         login?: number;
         unauthenticated?: number;
+        invalidBearer?: number;
     };
     fetchImpl?: typeof fetch;
 }

package/dist/http.js

@@ -27,12 +27,15 @@ import { ApiNetworkError, PharmadateClient, buildUserAgent } from './client.js';
 import { McpLimits, IpRateLimiter } from './limits.js';
 import { PrincipalCache, PrincipalError, credentialId, detectPrincipal } from './principal.js';
 import { createPharmadateServer } from './server.js';
-import { PharmadateOAuthProvider, SCOPE } from './auth/oauth-provider.js';
+import { PharmadateOAuthProvider, SCOPE, TOKEN_EXPIRED_MESSAGE } from './auth/oauth-provider.js';
+import { InvalidTokenError } from '@modelcontextprotocol/sdk/server/auth/errors.js';
 import { looksLikeMcpToken } from './auth/crypto.js';
 import { normalizeApiUrl, parseMode } from './config.js';
 import { logger } from './logger.js';
 import { scrubText } from './scrub.js';
 import { VERSION } from './version.js';
+/** Credenciales invalidas por minuto y IP a partir de las cuales se bloquean las keys `pk_` crudas sin validar (IPs de egress compartidas: umbral holgado). */
+export const DEFAULT_INVALID_BEARER_PER_MIN = 200;
 /** Origenes de navegador admitidos por defecto (los clientes MCP nativos no mandan `Origin`). */
 export const DEFAULT_ALLOWED_ORIGINS = ['https://claude.ai', 'https://claude.com', 'https://chatgpt.com', 'https://chat.openai.com'];
 /**
@@ -74,6 +77,7 @@ export function createMcpRouter(options) {
     const unauthLimiter = new IpRateLimiter(options.ipRateLimits?.unauthenticated ?? 30);
     const loginLimiter = new IpRateLimiter(options.ipRateLimits?.login ?? 10);
     const oauthLimiter = new IpRateLimiter(options.ipRateLimits?.oauth ?? 30);
+    const invalidBearerLimiter = new IpRateLimiter(options.ipRateLimits?.invalidBearer ?? DEFAULT_INVALID_BEARER_PER_MIN);
     const fetchImpl = options.fetchImpl;
     const hops = options.proxyHops ?? 2;
     const allowedHosts = options.allowedHosts ?? [publicUrl.hostname, 'localhost', '127.0.0.1', '[::1]'];
@@ -98,7 +102,12 @@ export function createMcpRouter(options) {
             return { ok: false, reason: 'unavailable', message: err instanceof Error ? scrubText(err.message) : 'error' };
         }
     };
-    const provider = new PharmadateOAuthProvider({ secret: options.oauthSecret, validateKey, resourceUrl });
+    const provider = new PharmadateOAuthProvider({
+        secret: options.oauthSecret,
+        validateKey,
+        resourceUrl,
+        ...(options.trustedRedirects ? { trustedRedirects: options.trustedRedirects } : {}),
+    });
     const resourceMetadataUrl = getOAuthProtectedResourceMetadataUrl(resourceUrl);
     const limitIp = (limiter) => (req, res, next) => {
         if (limiter.allow(clientIp(req, hops)))
@@ -161,33 +170,52 @@ export function createMcpRouter(options) {
         res.set('Allow', 'POST, OPTIONS').status(405).json(jsonRpcError(-32000, 'Metodo no permitido: este servidor es stateless, usa POST.'));
     });
     router.post('/mcp', express.json({ limit: '1mb' }), async (req, res) => {
+        const ip = clientIp(req, hops);
         const bearer = extractBearer(req.headers.authorization);
         if (!bearer) {
-            if (!unauthLimiter.allow(clientIp(req, hops))) {
+            if (!unauthLimiter.allow(ip)) {
                 res.set('Retry-After', '60').status(429).json(jsonRpcError(-32000, 'Demasiadas peticiones sin autenticar.'));
                 return;
             }
             return unauthorized(res, 'Falta la credencial.');
         }
+        // Credenciales invalidas. El bloqueo por IP protege la llamada por loopback (`cache.resolve`) que cuesta una key cruda sin comprobar, asi que
+        // SOLO se aplica a bearers `pk_` crudos que no estan en la cache de roles. Claude y ChatGPT salen por IPs compartidas: un token OAuth que
+        // `verifyAccessToken` ha validado nunca se bloquea ni suma al contador (aunque su key haya sido revocada), y un token caducado (lo normal
+        // cada hora) tampoco suma. Suman las keys crudas rechazadas por la API, los tokens falsificados y los bearers que no son de este servidor.
+        const bloqueada = !invalidBearerLimiter.peek(ip);
+        const demasiados = () => {
+            res.set('Retry-After', '60').status(429).json(jsonRpcError(-32000, 'Demasiados intentos con una credencial invalida, espera un minuto.'));
+        };
+        const rechazar = (descripcion, cuenta = true) => {
+            if (cuenta)
+                invalidBearerLimiter.hit(ip);
+            unauthorized(res, descripcion);
+        };
         let apiKey;
+        let viaOAuth = false;
         if (looksLikeMcpToken(bearer)) {
             try {
                 const info = await provider.verifyAccessToken(bearer);
                 if (info.resource && info.resource.toString().replace(/\/$/, '') !== resourceUrl.toString().replace(/\/$/, '')) {
-                    return unauthorized(res, 'Token emitido para otro recurso.');
+                    return rechazar('Token emitido para otro recurso.');
                 }
                 apiKey = String(info.extra.apiKey);
+                viaOAuth = true;
             }
-            catch {
-                return unauthorized(res, 'Token invalido o caducado.');
+            catch (err) {
+                const caducado = err instanceof InvalidTokenError && err.message === TOKEN_EXPIRED_MESSAGE;
+                return rechazar('Token invalido o caducado.', !caducado);
             }
         }
         else if (bearer.startsWith('pk_')) {
             apiKey = bearer;
         }
         else {
-            return unauthorized(res, 'Credencial no reconocida.');
+            return rechazar('Credencial no reconocida.');
         }
+        if (!viaOAuth && bloqueada && !cache.get(credentialId(apiKey)))
+            return demasiados();
         const client = newClient(apiKey, req);
         let principal;
         try {
@@ -195,13 +223,25 @@ export function createMcpRouter(options) {
         }
         catch (err) {
             if (err instanceof PrincipalError && err.kind === 'unauthorized')
-                return unauthorized(res, 'La API key no es valida, o fue rotada o revocada.');
+                return rechazar('La API key no es valida, o fue rotada o revocada.', !viaOAuth);
             logger.warn({ err: err instanceof Error ? err.message : String(err) }, 'no se pudo confirmar la credencial');
             res.status(err instanceof ApiNetworkError || err instanceof PrincipalError ? 503 : 500).json(jsonRpcError(-32603, 'No se pudo comprobar la credencial con la API de Pharmadate.'));
             return;
         }
-        const server = createPharmadateServer({ principal, client, credentialId: credentialId(apiKey), mode, limits });
-        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        // Express 4 no recoge las promesas rechazadas de un handler async: una excepcion aqui seria un unhandledRejection (en Node 20,
+        // el proceso entero, o sea la plataforma). Se atrapa y se responde un 500 JSON-RPC.
+        let server;
+        let transport;
+        try {
+            server = createPharmadateServer({ principal, client, credentialId: credentialId(apiKey), mode, limits });
+            transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        }
+        catch (err) {
+            logger.error({ err }, 'no se pudo crear el servidor MCP de la peticion');
+            if (!res.headersSent)
+                res.status(500).json(jsonRpcError(-32603, 'Error interno del servidor MCP.'));
+            return;
+        }
         res.on('close', () => {
             void transport.close();
             void server.close();

package/dist/index.js

@@ -79,17 +79,20 @@ async function runStdio() {
 async function runHttp() {
     const { default: express } = await import('express');
     const { createMcpRouter } = await import('./http.js');
+    const { secretProblem } = await import('./auth/crypto.js');
     const port = Number(process.env['MCP_PORT'] ?? 3333);
     const publicUrl = process.env['MCP_PUBLIC_URL'] ?? `http://localhost:${port}`;
     const secret = process.env['MCP_OAUTH_SECRET'] ?? '';
-    if (secret.length < 32)
-        fail('MCP_OAUTH_SECRET debe tener al menos 32 caracteres.');
+    const problemaSecreto = secretProblem(secret);
+    if (problemaSecreto)
+        fail(problemaSecreto);
     const { router } = createMcpRouter({
         apiBaseUrl: process.env['PHARMADATE_API_URL'] ?? DEFAULT_API_URL,
         publicUrl,
         oauthSecret: secret,
         mode: parseMode(process.env['MCP_REMOTE_MODE'], 'STANDARD'),
         allowedOrigins: (process.env['MCP_ALLOWED_ORIGINS'] ?? '').split(',').map((s) => s.trim()).filter(Boolean),
+        trustedRedirects: (process.env['MCP_ALLOWED_REDIRECTS'] ?? '').split(',').map((s) => s.trim()).filter(Boolean),
     });
     const app = express();
     app.disable('x-powered-by');

package/dist/limits.d.ts

@@ -49,13 +49,26 @@ export declare class McpLimits {
     check(credentialId: string, isOrder: boolean): string | null;
     startPurgeTimers(): () => void;
 }
-/** Limitador simple por IP para los endpoints sin autenticar (OAuth, 401). */
+/** Tope por defecto de IPs distintas que recuerda un {@link IpRateLimiter}. */
+export declare const DEFAULT_IP_LIMITER_ENTRIES = 10000;
+/**
+ * Limitador simple por IP para los endpoints sin autenticar (OAuth, 401, bearers invalidos).
+ *
+ * El mapa tiene TOPE (`maxEntries`): quien barra IPs distintas (un /64 de IPv6 da 2^64) no puede agotar la memoria del proceso.
+ * Al llegar al tope se descartan las IPs menos recientes: perder el contador de una IP antigua solo le da otra ventana.
+ */
 export declare class IpRateLimiter {
     readonly max: number;
     private readonly windowMs;
     private readonly now;
+    private readonly maxEntries;
     private readonly hits;
-    constructor(max: number, windowMs?: number, now?: () => number);
-    /** `true` si puede pasar. */
+    constructor(max: number, windowMs?: number, now?: () => number, maxEntries?: number);
+    /** `true` si puede pasar, y lo cuenta. */
     allow(ip: string): boolean;
+    /** `true` si la IP esta por debajo del limite. NO cuenta nada (para comprobar antes de hacer un trabajo caro). */
+    peek(ip: string): boolean;
+    /** Cuenta un intento de la IP (p. ej. una credencial rechazada), pase o no el limite. */
+    hit(ip: string): void;
+    get size(): number;
 }

package/dist/limits.js

@@ -91,32 +91,62 @@ export class McpLimits {
         };
     }
 }
-/** Limitador simple por IP para los endpoints sin autenticar (OAuth, 401). */
+/** Tope por defecto de IPs distintas que recuerda un {@link IpRateLimiter}. */
+export const DEFAULT_IP_LIMITER_ENTRIES = 10_000;
+/**
+ * Limitador simple por IP para los endpoints sin autenticar (OAuth, 401, bearers invalidos).
+ *
+ * El mapa tiene TOPE (`maxEntries`): quien barra IPs distintas (un /64 de IPv6 da 2^64) no puede agotar la memoria del proceso.
+ * Al llegar al tope se descartan las IPs menos recientes: perder el contador de una IP antigua solo le da otra ventana.
+ */
 export class IpRateLimiter {
     max;
     windowMs;
     now;
+    maxEntries;
     hits = new Map();
-    constructor(max, windowMs = 60_000, now = Date.now) {
+    constructor(max, windowMs = 60_000, now = Date.now, maxEntries = DEFAULT_IP_LIMITER_ENTRIES) {
         this.max = max;
         this.windowMs = windowMs;
         this.now = now;
+        this.maxEntries = maxEntries;
     }
-    /** `true` si puede pasar. */
+    /** `true` si puede pasar, y lo cuenta. */
     allow(ip) {
+        if (!this.peek(ip))
+            return false;
+        this.hit(ip);
+        return true;
+    }
+    /** `true` si la IP esta por debajo del limite. NO cuenta nada (para comprobar antes de hacer un trabajo caro). */
+    peek(ip) {
+        const now = this.now();
+        const ts = this.hits.get(ip);
+        if (!ts)
+            return true;
+        return ts.filter((t) => now - t < this.windowMs).length < this.max;
+    }
+    /** Cuenta un intento de la IP (p. ej. una credencial rechazada), pase o no el limite. */
+    hit(ip) {
         const now = this.now();
-        if (this.hits.size > PURGE_THRESHOLD) {
+        if (this.hits.size >= PURGE_THRESHOLD) {
             for (const [k, ts] of this.hits)
                 if (ts.every((t) => now - t >= this.windowMs))
                     this.hits.delete(k);
         }
         const recent = (this.hits.get(ip) ?? []).filter((t) => now - t < this.windowMs);
-        if (recent.length >= this.max) {
-            this.hits.set(ip, recent);
-            return false;
-        }
         recent.push(now);
+        // delete + set deja la IP la ultima del orden de insercion: lo primero del mapa es lo menos reciente
+        this.hits.delete(ip);
         this.hits.set(ip, recent);
-        return true;
+        while (this.hits.size > this.maxEntries) {
+            const masAntigua = this.hits.keys().next().value;
+            if (masAntigua === undefined)
+                break;
+            this.hits.delete(masAntigua);
+        }
+    }
+    get size() {
+        return this.hits.size;
     }
 }

package/dist/logger.d.ts

@@ -4,5 +4,7 @@
  *
  * @module logger
  */
-import pino from 'pino';
+import pino, { type DestinationStream } from 'pino';
+/** Crea el logger. Aparte para poder probarlo con un destino propio; el de la aplicacion va a stderr. */
+export declare function createLogger(destination: DestinationStream, level?: string): pino.Logger<never, boolean>;
 export declare const logger: pino.Logger<never, boolean>;

package/dist/logger.js

@@ -8,23 +8,27 @@ import pino from 'pino';
 import { scrubDeep, scrubText } from './scrub.js';
 import { VERSION } from './version.js';
 const nivel = process.env['LOG_LEVEL'] ?? 'info';
-export const logger = pino({
-    level: nivel,
-    base: { service: 'pharmadate-mcp', version: VERSION },
-    redact: {
-        paths: ['authorization', 'req.headers.authorization', 'headers.authorization', '*.authorization', 'api_key', '*.api_key', 'access_token', 'refresh_token', '*.access_token', '*.refresh_token'],
-        censor: '[REDACTED]',
-    },
-    timestamp: pino.stdTimeFunctions.isoTime,
-    formatters: {
-        level: (label) => ({ level: label }),
-        log: (objeto) => scrubDeep(objeto),
-    },
-    hooks: {
-        logMethod(args, method) {
-            // El mensaje (primer string) tambien se redacta
-            const copia = args.map((a) => (typeof a === 'string' ? scrubText(a) : a));
-            return method.apply(this, copia);
+/** Crea el logger. Aparte para poder probarlo con un destino propio; el de la aplicacion va a stderr. */
+export function createLogger(destination, level = nivel) {
+    return pino({
+        level,
+        base: { service: 'pharmadate-mcp', version: VERSION },
+        redact: {
+            paths: ['authorization', 'req.headers.authorization', 'headers.authorization', '*.authorization', 'api_key', '*.api_key', 'access_token', 'refresh_token', '*.access_token', '*.refresh_token'],
+            censor: '[REDACTED]',
         },
-    },
-}, pino.destination({ dest: 2, sync: false }));
+        timestamp: pino.stdTimeFunctions.isoTime,
+        formatters: {
+            level: (label) => ({ level: label }),
+            log: (objeto) => scrubDeep(objeto),
+        },
+        hooks: {
+            logMethod(args, method) {
+                // El mensaje (primer string) tambien se redacta
+                const copia = args.map((a) => (typeof a === 'string' ? scrubText(a) : a));
+                return method.apply(this, copia);
+            },
+        },
+    }, destination);
+}
+export const logger = createLogger(pino.destination({ dest: 2, sync: false }));

package/dist/scrub.d.ts

@@ -8,5 +8,11 @@
  */
 /** Sustituye las credenciales de un texto por marcas inofensivas. */
 export declare function scrubText(texto: string): string;
-/** Igual que {@link scrubText} pero recorre objetos y listas. No muta el original. */
+/** Un `Error` como objeto plano y redactado: sus campos no son enumerables y `Object.entries(err)` daba `{}` (se perdia el motivo). */
+export declare function scrubError(err: Error): {
+    name: string;
+    message: string;
+    stack?: string;
+};
+/** Igual que {@link scrubText} pero recorre objetos y listas. No muta el original. Los `Error` salen como `{name, message, stack}`. */
 export declare function scrubDeep<T>(valor: T, profundidad?: number): T;

package/dist/scrub.js

@@ -19,8 +19,17 @@ export function scrubText(texto) {
         .replace(TOKEN_RE, '[REDACTED_TOKEN]')
         .replace(BEARER_RE, '$1[REDACTED]');
 }
-/** Igual que {@link scrubText} pero recorre objetos y listas. No muta el original. */
+/** Un `Error` como objeto plano y redactado: sus campos no son enumerables y `Object.entries(err)` daba `{}` (se perdia el motivo). */
+export function scrubError(err) {
+    const salida = { name: err.name, message: scrubText(err.message) };
+    if (typeof err.stack === 'string')
+        salida.stack = scrubText(err.stack);
+    return salida;
+}
+/** Igual que {@link scrubText} pero recorre objetos y listas. No muta el original. Los `Error` salen como `{name, message, stack}`. */
 export function scrubDeep(valor, profundidad = 0) {
+    if (valor instanceof Error)
+        return scrubError(valor);
     if (profundidad > 12)
         return valor;
     if (typeof valor === 'string')

package/dist/tools/common.js

@@ -22,8 +22,10 @@ const ITEMS = z
     .min(1)
     .max(MAX_LINES)
     .describe(`Lineas de la cesta (entre 1 y ${MAX_LINES}). Un mismo CN repetido se fusiona.`);
+/** Un CN que va en la ruta (`/conditions/{cn}`): solo digitos. Se comprueba aqui y no se confia en `encodeURIComponent`. */
+const CN_RUTA = z.string().regex(/^\d{1,20}$/, 'Un codigo nacional son solo digitos (hasta 20).');
 const ORDER_ID = z.number().int().positive().describe('`order_id` del pedido en Pharmadate.');
-const SHIPMENT_ID = z.string().min(1).max(100).describe('Identificador del envio (`shp_...`, opaco y global).');
+const SHIPMENT_ID = z.string().max(100).regex(/^shp_[\w-]+$/, 'Un shipment_id tiene la forma shp_... (letras, digitos, _ y -).').describe('Identificador del envio (`shp_...`, opaco y global).');
 const PAGE = z.number().int().min(1).optional().describe('Pagina (empieza en 1).');
 /**
  * Construye las herramientas comunes para un rol: solo el partner ve el argumento `pharmacy` (opcional si hay una farmacia
@@ -85,7 +87,7 @@ export function commonTools(role, opts = {}) {
             http: { method: 'GET', path: '/api/v1/conditions/{cn}' },
             roles: BOTH_ROLES,
             annotations: READ_ANN,
-            inputSchema: { ...farmacia, cn: z.string().min(1).max(20).describe('Codigo nacional.') },
+            inputSchema: { ...farmacia, cn: CN_RUTA.describe('Codigo nacional (solo digitos).') },
             handler: async (args, ctx) => operate(ctx, args.pharmacy, { method: 'GET', path: `/v1/conditions/${encodeURIComponent(args.cn)}` }),
         },
         {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pharmadate/mcp",
   "mcpName": "es.pharmadatepedido/mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Servidor MCP de Pharmadate: consulta el catalogo, valora y cursa pedidos y gestiona las farmacias de un partner desde Claude, ChatGPT, Cursor o cualquier cliente MCP. 19 herramientas sobre la API v1, stdio, Streamable HTTP y OAuth 2.1.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,6 +12,7 @@
   "files": [
     "dist/",
     "README.md",
+    "LICENSE",
     "server.json"
   ],
   "engines": {
@@ -22,7 +23,7 @@
     "email": "samuel.fraga@nubiia.es",
     "url": "https://nubiia.es"
   },
-  "license": "UNLICENSED",
+  "license": "MIT",
   "homepage": "https://www.pharmadatepedido.es/api-docs/mcp.html",
   "bugs": {
     "email": "samuel.fraga@nubiia.es"

package/server.json

@@ -2,8 +2,8 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "es.pharmadatepedido/mcp",
   "title": "Pharmadate",
-  "description": "Pharmadate: catalogo, valoracion y pedidos de farmacias a laboratorios y almacen, y gestion de farmacias para partners.",
-  "version": "0.1.0",
+  "description": "Pharmadate: catalogo, valoracion y pedidos de farmacia, y gestion de farmacias para partners.",
+  "version": "0.1.1",
   "websiteUrl": "https://www.pharmadatepedido.es/api-docs/mcp.html",
   "repository": {
     "url": "https://github.com/Rubenga11/pedido-directo",
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@pharmadate/mcp",
-      "version": "0.1.0",
+      "version": "0.1.1",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"