@pharmadate/mcp 0.0.0-stage → 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,54 @@
+export declare const TIMEOUT_MS = 15000;
+export declare const LONG_TIMEOUT_MS = 30000;
+/** Campos del cuerpo que dispararian el alta automatica de una farmacia. Prohibidos. */
+export declare const FORBIDDEN_BODY_FIELDS: readonly ["pharmacy", "pharmacy_ref"];
+export interface ClientOptions {
+    /** URL de la API terminada en `/api`, p. ej. `https://www.pharmadatepedido.es/api`. */
+    baseUrl: string;
+    apiKey: string;
+    userAgent: string;
+    /** IP real del usuario (modo remoto). Va en `X-Forwarded-For`. */
+    forwardedFor?: string;
+    fetchImpl?: typeof fetch;
+}
+export interface ApiRequest {
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    /** Ruta bajo `/api`, p. ej. `/v1/orders`. */
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: Record<string, unknown>;
+    /** CIF de la farmacia ya resuelta: va en `X-Pharmacy-Ref`. Solo con credencial de partner. */
+    pharmacyCif?: string;
+    timeoutMs?: number;
+}
+export interface ApiResponse {
+    status: number;
+    ok: boolean;
+    /** JSON de la respuesta; si no era JSON, `{ __text }`. */
+    body: unknown;
+    requestId: string | null;
+    retryAfter: string | null;
+}
+/** La API no respondio (red, DNS, timeout). El mensaje no contiene credenciales. */
+export declare class ApiNetworkError extends Error {
+    readonly timedOut: boolean;
+    constructor(message: string, timedOut: boolean);
+}
+export declare class PharmadateClient {
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private userAgent;
+    private readonly forwardedFor;
+    private readonly fetchImpl;
+    constructor(options: ClientOptions);
+    /** Actualiza el User-Agent (stdio: cuando el cliente MCP dice como se llama). */
+    setUserAgent(userAgent: string): void;
+    /** Hace la llamada. Un 4xx/5xx NO lanza: devuelve la respuesta para que quien llama la traduzca. */
+    request(req: ApiRequest): Promise<ApiResponse>;
+    /** Descarga un texto publico (sin credenciales): el OpenAPI que sirve el frontend. */
+    fetchPublicText(absoluteUrl: string, timeoutMs?: number): Promise<string>;
+}
+/** Lanza si el cuerpo trae un campo que daria de alta una farmacia por la puerta de atras. */
+export declare function assertNoPharmacyInBody(body: Record<string, unknown>): void;
+/** `pharmadate-mcp/<version> (remote|stdio; client=<nombre>)` */
+export declare function buildUserAgent(version: string, transport: 'remote' | 'stdio', clientLabel: string | undefined): string;

package/dist/client.js

@@ -0,0 +1,131 @@
+/**
+ * Cliente HTTP de la API v1 de Pharmadate.
+ *
+ * Es el UNICO sitio por donde el MCP habla con la plataforma: no hay acceso a base de datos y toda la autorizacion la
+ * hace la API. Responsabilidades:
+ *
+ * - Timeouts y errores de red convertidos en {@link ApiNetworkError} (con las keys ya redactadas).
+ * - `User-Agent: pharmadate-mcp/<version> (remote|stdio; client=...)` y la IP real reenviada en `X-Forwarded-For`,
+ *   para que la auditoria de la API (`api_audit`) atribuya cada llamada.
+ * - **Salvaguarda de seguridad**: nunca se envia `pharmacy` ni `pharmacy_ref` en el cuerpo. Con una credencial de partner,
+ *   la API da de alta AUTOMATICAMENTE la farmacia de un CIF desconocido; por eso la farmacia se resuelve antes
+ *   ({@link ./pharmacy-resolver.ts}) y aqui se impide, como defensa en profundidad, que un cuerpo lleve esos campos.
+ *
+ * @module client
+ */
+import { scrubText } from './scrub.js';
+export const TIMEOUT_MS = 15_000;
+export const LONG_TIMEOUT_MS = 30_000;
+/** Campos del cuerpo que dispararian el alta automatica de una farmacia. Prohibidos. */
+export const FORBIDDEN_BODY_FIELDS = ['pharmacy', 'pharmacy_ref'];
+/** La API no respondio (red, DNS, timeout). El mensaje no contiene credenciales. */
+export class ApiNetworkError extends Error {
+    timedOut;
+    constructor(message, timedOut) {
+        super(scrubText(message));
+        this.timedOut = timedOut;
+        this.name = 'ApiNetworkError';
+    }
+}
+export class PharmadateClient {
+    baseUrl;
+    apiKey;
+    userAgent;
+    forwardedFor;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.apiKey = options.apiKey;
+        this.userAgent = options.userAgent;
+        this.forwardedFor = options.forwardedFor;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    /** Actualiza el User-Agent (stdio: cuando el cliente MCP dice como se llama). */
+    setUserAgent(userAgent) {
+        this.userAgent = userAgent;
+    }
+    /** Hace la llamada. Un 4xx/5xx NO lanza: devuelve la respuesta para que quien llama la traduzca. */
+    async request(req) {
+        if (req.body)
+            assertNoPharmacyInBody(req.body);
+        const url = new URL(this.baseUrl + req.path);
+        for (const [k, v] of Object.entries(req.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: 'application/json',
+            'User-Agent': this.userAgent,
+        };
+        if (this.forwardedFor)
+            headers['X-Forwarded-For'] = this.forwardedFor;
+        if (req.pharmacyCif)
+            headers['X-Pharmacy-Ref'] = req.pharmacyCif;
+        if (req.body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        const timeoutMs = req.timeoutMs ?? TIMEOUT_MS;
+        let res;
+        try {
+            res = await this.fetchImpl(url, {
+                method: req.method,
+                headers,
+                body: req.body !== undefined ? JSON.stringify(req.body) : undefined,
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: 'error',
+            });
+        }
+        catch (err) {
+            const timedOut = err instanceof Error && (err.name === 'TimeoutError' || err.name === 'AbortError');
+            throw new ApiNetworkError(timedOut ? `La API de Pharmadate no respondio en ${Math.round(timeoutMs / 1000)} s.` : `No se pudo contactar con la API de Pharmadate: ${err instanceof Error ? err.message : String(err)}`, timedOut);
+        }
+        const texto = await res.text();
+        let body = null;
+        if (texto) {
+            try {
+                body = JSON.parse(texto);
+            }
+            catch {
+                body = { __text: texto.slice(0, 500) };
+            }
+        }
+        return {
+            status: res.status,
+            ok: res.ok,
+            body,
+            requestId: res.headers.get('x-request-id'),
+            retryAfter: res.headers.get('retry-after'),
+        };
+    }
+    /** Descarga un texto publico (sin credenciales): el OpenAPI que sirve el frontend. */
+    async fetchPublicText(absoluteUrl, timeoutMs = TIMEOUT_MS) {
+        try {
+            const res = await this.fetchImpl(absoluteUrl, {
+                headers: { 'User-Agent': this.userAgent },
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: 'error',
+            });
+            if (!res.ok)
+                throw new ApiNetworkError(`Respuesta ${res.status} al descargar ${absoluteUrl}`, false);
+            return await res.text();
+        }
+        catch (err) {
+            if (err instanceof ApiNetworkError)
+                throw err;
+            throw new ApiNetworkError(`No se pudo descargar ${absoluteUrl}: ${err instanceof Error ? err.message : String(err)}`, false);
+        }
+    }
+}
+/** Lanza si el cuerpo trae un campo que daria de alta una farmacia por la puerta de atras. */
+export function assertNoPharmacyInBody(body) {
+    for (const campo of FORBIDDEN_BODY_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(body, campo)) {
+            throw new Error(`Bug del MCP: el cuerpo no puede llevar "${campo}" (daria de alta una farmacia automaticamente).`);
+        }
+    }
+}
+/** `pharmadate-mcp/<version> (remote|stdio; client=<nombre>)` */
+export function buildUserAgent(version, transport, clientLabel) {
+    const limpio = (clientLabel ?? 'unknown').replace(/[^\w ./()-]/g, '').slice(0, 80).trim() || 'unknown';
+    return `pharmadate-mcp/${version} (${transport}; client=${limpio})`;
+}

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Configuracion por variables de entorno.
+ *
+ * stdio:  PHARMADATE_API_KEY, PHARMADATE_API_URL, PHARMADATE_PHARMACY_REF (opcional), PHARMADATE_MCP_MODE=READ_ONLY|STANDARD
+ * remoto: MCP_PUBLIC_URL, MCP_OAUTH_SECRET, MCP_ALLOWED_ORIGINS (opcional), MCP_REMOTE_MODE=READ_ONLY|STANDARD
+ *
+ * @module config
+ */
+export declare const DEFAULT_API_URL = "https://www.pharmadatepedido.es/api";
+export type OperationMode = 'READ_ONLY' | 'STANDARD';
+/** Interpreta un modo; lo desconocido cae en `porDefecto`. */
+export declare function parseMode(raw: string | undefined, porDefecto: OperationMode): OperationMode;
+/** Quita la barra final y valida que sea http(s). */
+export declare function normalizeApiUrl(raw: string | undefined): string;
+/** Origen (esquema + host) de la API, de donde se sirve /api-docs/openapi.yaml. */
+export declare function apiOrigin(apiUrl: string): string;

package/dist/config.js

@@ -0,0 +1,28 @@
+/**
+ * Configuracion por variables de entorno.
+ *
+ * stdio:  PHARMADATE_API_KEY, PHARMADATE_API_URL, PHARMADATE_PHARMACY_REF (opcional), PHARMADATE_MCP_MODE=READ_ONLY|STANDARD
+ * remoto: MCP_PUBLIC_URL, MCP_OAUTH_SECRET, MCP_ALLOWED_ORIGINS (opcional), MCP_REMOTE_MODE=READ_ONLY|STANDARD
+ *
+ * @module config
+ */
+export const DEFAULT_API_URL = 'https://www.pharmadatepedido.es/api';
+/** Interpreta un modo; lo desconocido cae en `porDefecto`. */
+export function parseMode(raw, porDefecto) {
+    const v = (raw ?? '').trim().toUpperCase();
+    if (v === 'READ_ONLY' || v === 'STANDARD')
+        return v;
+    return porDefecto;
+}
+/** Quita la barra final y valida que sea http(s). */
+export function normalizeApiUrl(raw) {
+    const valor = (raw ?? '').trim() || DEFAULT_API_URL;
+    const url = new URL(valor);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:')
+        throw new Error('PHARMADATE_API_URL tiene que ser http(s).');
+    return valor.replace(/\/+$/, '');
+}
+/** Origen (esquema + host) de la API, de donde se sirve /api-docs/openapi.yaml. */
+export function apiOrigin(apiUrl) {
+    return new URL(apiUrl).origin;
+}

package/dist/http.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Transporte Streamable HTTP stateless + OAuth 2.1 sin estado, como un `express.Router`.
+ *
+ *   const { router } = createMcpRouter({ apiBaseUrl: 'http://127.0.0.1:3001/api', publicUrl, oauthSecret });
+ *   app.use(router);      // ANTES de cors() y de express.json() de la app anfitriona (backend/server.js)
+ *
+ * Rutas (en la raiz, como exige OAuth/RFC 8414 y RFC 9728):
+ *   POST /mcp                                      JSON-RPC (Bearer: API key o access token del OAuth)
+ *   GET|DELETE /mcp                                405 (stateless: no hay sesiones ni SSE)
+ *   GET /.well-known/oauth-authorization-server    metadata del servidor de autorizacion
+ *   GET /.well-known/oauth-protected-resource/mcp  metadata del recurso (RFC 9728)
+ *   POST /register                                 registro dinamico de clientes (DCR)
+ *   GET /authorize  +  POST /oauth/login           pagina donde se pega la API key
+ *   POST /token                                    code / refresh -> tokens
+ *
+ * STATELESS: se crea un `McpServer` por peticion, atado a la credencial de ESA peticion (`sessionIdGenerator: undefined`,
+ * `enableJsonResponse: true`). Asi funciona con varias instancias detras del balanceador. Proteccion contra DNS
+ * rebinding: `Host` y `Origin` se validan.
+ *
+ * @module http
+ */
+import { Router, type Request } from 'express';
+import { McpLimits } from './limits.js';
+import { type OperationMode } from './config.js';
+/** Origenes de navegador admitidos por defecto (los clientes MCP nativos no mandan `Origin`). */
+export declare const DEFAULT_ALLOWED_ORIGINS: string[];
+export interface McpRouterOptions {
+    /** API por loopback, p. ej. `http://127.0.0.1:3001/api`. */
+    apiBaseUrl: string;
+    /** URL publica de la plataforma (issuer del OAuth y base de `/mcp`), p. ej. `https://www.pharmadatepedido.es`. */
+    publicUrl: string;
+    /** Secreto de 32+ caracteres para cifrar los tokens. */
+    oauthSecret: string;
+    /** Hostnames admitidos en la cabecera Host (por defecto, el de `publicUrl` y los de loopback). */
+    allowedHosts?: string[];
+    /** Origenes de navegador admitidos (se suman a los de {@link DEFAULT_ALLOWED_ORIGINS} y al de `publicUrl`). */
+    allowedOrigins?: string[];
+    /** Proxies de confianza delante de la app para leer `X-Forwarded-For` (ver {@link clientIp}). Por defecto 2 (ALB + nginx); 1 en la beta. */
+    proxyHops?: number;
+    /** 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). */
+    ipRateLimits?: {
+        oauth?: number;
+        login?: number;
+        unauthenticated?: number;
+    };
+    fetchImpl?: typeof fetch;
+}
+export interface McpRouterHandle {
+    router: Router;
+    /** Para los tests y para parar los temporizadores. */
+    shutdown: () => void;
+}
+/**
+ * IP real del cliente a partir de `X-Forwarded-For`.
+ *
+ * Cada proxy de confianza AÑADE por la derecha la direccion de quien le hablo, y lo que el cliente haya puesto a la izquierda
+ * se puede falsear. `hops` es cuantos proxies de confianza hay delante de la app: la IP real es la `hops`-esima por la derecha.
+ *   - Elastic Beanstalk con ALB + nginx: 2 (nginx anade la IP del ALB y el ALB la del cliente)  <- por defecto
+ *   - Beta (instancia unica, solo nginx): 1
+ * Sin cabecera (ejecucion local) se usa la direccion del socket.
+ */
+export declare function clientIp(req: Request, hops?: number): string;
+/** Extrae el token de `Authorization: Bearer ...` sin expresiones regulares (lineal, longitud acotada). */
+export declare function extractBearer(header: unknown): string | undefined;
+export declare function createMcpRouter(options: McpRouterOptions): McpRouterHandle;

package/dist/http.js

@@ -0,0 +1,232 @@
+/**
+ * Transporte Streamable HTTP stateless + OAuth 2.1 sin estado, como un `express.Router`.
+ *
+ *   const { router } = createMcpRouter({ apiBaseUrl: 'http://127.0.0.1:3001/api', publicUrl, oauthSecret });
+ *   app.use(router);      // ANTES de cors() y de express.json() de la app anfitriona (backend/server.js)
+ *
+ * Rutas (en la raiz, como exige OAuth/RFC 8414 y RFC 9728):
+ *   POST /mcp                                      JSON-RPC (Bearer: API key o access token del OAuth)
+ *   GET|DELETE /mcp                                405 (stateless: no hay sesiones ni SSE)
+ *   GET /.well-known/oauth-authorization-server    metadata del servidor de autorizacion
+ *   GET /.well-known/oauth-protected-resource/mcp  metadata del recurso (RFC 9728)
+ *   POST /register                                 registro dinamico de clientes (DCR)
+ *   GET /authorize  +  POST /oauth/login           pagina donde se pega la API key
+ *   POST /token                                    code / refresh -> tokens
+ *
+ * STATELESS: se crea un `McpServer` por peticion, atado a la credencial de ESA peticion (`sessionIdGenerator: undefined`,
+ * `enableJsonResponse: true`). Asi funciona con varias instancias detras del balanceador. Proteccion contra DNS
+ * rebinding: `Host` y `Origin` se validan.
+ *
+ * @module http
+ */
+import express, { Router } from 'express';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { mcpAuthRouter, getOAuthProtectedResourceMetadataUrl } from '@modelcontextprotocol/sdk/server/auth/router.js';
+import { hostHeaderValidation } from '@modelcontextprotocol/sdk/server/middleware/hostHeaderValidation.js';
+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 { 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';
+/** 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'];
+/**
+ * IP real del cliente a partir de `X-Forwarded-For`.
+ *
+ * Cada proxy de confianza AÑADE por la derecha la direccion de quien le hablo, y lo que el cliente haya puesto a la izquierda
+ * se puede falsear. `hops` es cuantos proxies de confianza hay delante de la app: la IP real es la `hops`-esima por la derecha.
+ *   - Elastic Beanstalk con ALB + nginx: 2 (nginx anade la IP del ALB y el ALB la del cliente)  <- por defecto
+ *   - Beta (instancia unica, solo nginx): 1
+ * Sin cabecera (ejecucion local) se usa la direccion del socket.
+ */
+export function clientIp(req, hops = 2) {
+    const xff = req.headers['x-forwarded-for'];
+    const lista = (Array.isArray(xff) ? xff.join(',') : xff ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+    if (!lista.length)
+        return req.socket.remoteAddress ?? 'unknown';
+    return lista[Math.max(0, lista.length - Math.max(1, hops))];
+}
+/** Extrae el token de `Authorization: Bearer ...` sin expresiones regulares (lineal, longitud acotada). */
+export function extractBearer(header) {
+    if (typeof header !== 'string' || header.length > 8_192)
+        return undefined;
+    if (header.slice(0, 7).toLowerCase() !== 'bearer ')
+        return undefined;
+    const token = header.slice(7).trim();
+    if (!token || /\s/.test(token))
+        return undefined;
+    return token;
+}
+const jsonRpcError = (code, message) => ({ jsonrpc: '2.0', error: { code, message }, id: null });
+export function createMcpRouter(options) {
+    const apiBaseUrl = normalizeApiUrl(options.apiBaseUrl);
+    const publicUrl = new URL(options.publicUrl);
+    const resourceUrl = new URL('/mcp', publicUrl);
+    const mode = options.mode ?? parseMode(undefined, 'STANDARD');
+    const limits = options.limits ?? new McpLimits();
+    const stopTimers = limits.startPurgeTimers();
+    const cache = new PrincipalCache();
+    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 fetchImpl = options.fetchImpl;
+    const hops = options.proxyHops ?? 2;
+    const allowedHosts = options.allowedHosts ?? [publicUrl.hostname, 'localhost', '127.0.0.1', '[::1]'];
+    const allowedOrigins = new Set([...DEFAULT_ALLOWED_ORIGINS, publicUrl.origin, ...(options.allowedOrigins ?? [])]);
+    const hostCheck = hostHeaderValidation(allowedHosts);
+    const newClient = (apiKey, req) => new PharmadateClient({
+        baseUrl: apiBaseUrl,
+        apiKey,
+        userAgent: buildUserAgent(VERSION, 'remote', String(req.headers['user-agent'] ?? '').split(' ')[0]),
+        forwardedFor: clientIp(req, hops),
+        ...(fetchImpl ? { fetchImpl } : {}),
+    });
+    /** Comprueba una key para el login y el refresh del OAuth. Solo partners y farmacias. */
+    const validateKey = async (apiKey) => {
+        try {
+            await detectPrincipal(new PharmadateClient({ baseUrl: apiBaseUrl, apiKey, userAgent: buildUserAgent(VERSION, 'remote', 'oauth'), ...(fetchImpl ? { fetchImpl } : {}) }));
+            return { ok: true };
+        }
+        catch (err) {
+            if (err instanceof PrincipalError && err.kind === 'unauthorized')
+                return { ok: false, reason: 'invalid', message: err.message };
+            return { ok: false, reason: 'unavailable', message: err instanceof Error ? scrubText(err.message) : 'error' };
+        }
+    };
+    const provider = new PharmadateOAuthProvider({ secret: options.oauthSecret, validateKey, resourceUrl });
+    const resourceMetadataUrl = getOAuthProtectedResourceMetadataUrl(resourceUrl);
+    const limitIp = (limiter) => (req, res, next) => {
+        if (limiter.allow(clientIp(req, hops)))
+            return next();
+        res.set('Retry-After', '60').status(429).json({ error: 'too_many_requests', error_description: 'Demasiadas peticiones, espera un minuto.' });
+    };
+    const unauthorized = (res, descripcion) => {
+        res
+            .set('WWW-Authenticate', `Bearer error="invalid_token", error_description="${descripcion.replace(/"/g, "'")}", resource_metadata="${resourceMetadataUrl}"`)
+            .status(401)
+            .json({ error: 'invalid_token', error_description: descripcion });
+    };
+    /** CORS manual para /mcp: solo origenes de la lista; sin `Origin` (clientes nativos) pasa. */
+    const mcpCors = (req, res, next) => {
+        const origin = req.headers.origin;
+        if (origin) {
+            if (!allowedOrigins.has(origin)) {
+                res.status(403).json(jsonRpcError(-32000, 'Origin no permitido.'));
+                return;
+            }
+            res.set({ 'Access-Control-Allow-Origin': origin, Vary: 'Origin', 'Access-Control-Expose-Headers': 'WWW-Authenticate, X-Request-Id' });
+        }
+        if (req.method === 'OPTIONS') {
+            res
+                .set({
+                'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                'Access-Control-Allow-Headers': String(req.headers['access-control-request-headers'] ?? 'Authorization, Content-Type, Accept, Mcp-Protocol-Version'),
+                'Access-Control-Max-Age': '600',
+            })
+                .status(204)
+                .end();
+            return;
+        }
+        next();
+    };
+    const router = Router();
+    // ---------------------------------------------------------------- OAuth
+    const oauthPaths = ['/authorize', '/token', '/register', '/oauth', '/.well-known'];
+    router.use(oauthPaths, hostCheck, limitIp(oauthLimiter));
+    router.post('/oauth/login', limitIp(loginLimiter), express.urlencoded({ extended: false, limit: '10kb' }), (req, res, next) => {
+        provider.handleLoginPost((req.body ?? {}), res).catch(next);
+    });
+    router.use(mcpAuthRouter({
+        provider,
+        issuerUrl: publicUrl,
+        baseUrl: publicUrl,
+        resourceServerUrl: resourceUrl,
+        scopesSupported: [SCOPE],
+        resourceName: 'Pharmadate',
+        // El limitador del SDK se basa en req.ip (tras el ALB seria la IP del balanceador, compartida por todos): lo hacemos arriba.
+        authorizationOptions: { rateLimit: false },
+        tokenOptions: { rateLimit: false },
+        clientRegistrationOptions: { rateLimit: false },
+    }));
+    // ---------------------------------------------------------------- /mcp
+    router.options('/mcp', hostCheck, mcpCors);
+    router.all('/mcp', hostCheck, mcpCors, (req, res, next) => {
+        if (req.method === 'POST')
+            return next();
+        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 bearer = extractBearer(req.headers.authorization);
+        if (!bearer) {
+            if (!unauthLimiter.allow(clientIp(req, hops))) {
+                res.set('Retry-After', '60').status(429).json(jsonRpcError(-32000, 'Demasiadas peticiones sin autenticar.'));
+                return;
+            }
+            return unauthorized(res, 'Falta la credencial.');
+        }
+        let apiKey;
+        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.');
+                }
+                apiKey = String(info.extra.apiKey);
+            }
+            catch {
+                return unauthorized(res, 'Token invalido o caducado.');
+            }
+        }
+        else if (bearer.startsWith('pk_')) {
+            apiKey = bearer;
+        }
+        else {
+            return unauthorized(res, 'Credencial no reconocida.');
+        }
+        const client = newClient(apiKey, req);
+        let principal;
+        try {
+            principal = await cache.resolve(apiKey, client);
+        }
+        catch (err) {
+            if (err instanceof PrincipalError && err.kind === 'unauthorized')
+                return unauthorized(res, 'La API key no es valida, o fue rotada o revocada.');
+            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 });
+        res.on('close', () => {
+            void transport.close();
+            void server.close();
+        });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (err) {
+            logger.error({ err }, 'error en POST /mcp');
+            if (!res.headersSent)
+                res.status(500).json(jsonRpcError(-32603, 'Error interno del servidor MCP.'));
+        }
+    });
+    // JSON mal formado, cuerpo demasiado grande, etc.
+    router.use((err, req, res, next) => {
+        if (res.headersSent)
+            return next(err);
+        const status = err.status ?? 500;
+        if (req.path === '/mcp') {
+            res.status(status >= 400 && status < 500 ? status : 500).json(jsonRpcError(status === 400 ? -32700 : -32603, status === 413 ? 'Cuerpo demasiado grande.' : 'Peticion no valida.'));
+            return;
+        }
+        logger.error({ err }, 'error en una ruta OAuth');
+        res.status(status >= 400 && status < 500 ? status : 500).json({ error: 'server_error' });
+    });
+    return { router, shutdown: stopTimers };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * CLI de pharmadate-mcp.
+ *
+ *   npx -y pharmadate-mcp                  stdio (Claude Desktop, Claude Code, Cursor, VS Code...)
+ *   npx -y pharmadate-mcp --transport=http servidor HTTP local de desarrollo (con OAuth)
+ *
+ * Variables de entorno (stdio):
+ *   PHARMADATE_API_KEY        obligatoria: key de partner (pk_partner_...) o de farmacia (pk_live_...)
+ *   PHARMADATE_API_URL        por defecto https://www.pharmadatepedido.es/api
+ *   PHARMADATE_PHARMACY_REF   opcional (solo partners): CIF de la farmacia con la que operar por defecto
+ *   PHARMADATE_MCP_MODE       READ_ONLY (por defecto) | STANDARD (permite escrituras)
+ *
+ * El stdout es el canal del protocolo: todo lo demas va a stderr.
+ *
+ * @module index
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { PharmadateClient, buildUserAgent } from './client.js';
+import { DEFAULT_API_URL, normalizeApiUrl, parseMode } from './config.js';
+import { McpLimits } from './limits.js';
+import { logger } from './logger.js';
+import { PrincipalError, credentialId, detectPrincipal } from './principal.js';
+import { createPharmadateServer } from './server.js';
+import { scrubText } from './scrub.js';
+import { VERSION } from './version.js';
+const AYUDA = `pharmadate-mcp ${VERSION}
+
+Uso:
+  pharmadate-mcp                    servidor stdio (lo normal)
+  pharmadate-mcp --transport=http   servidor HTTP local de desarrollo (MCP_PORT, MCP_PUBLIC_URL, MCP_OAUTH_SECRET)
+  pharmadate-mcp --version
+
+Variables de entorno (stdio):
+  PHARMADATE_API_KEY       key de partner (pk_partner_...) o de farmacia (pk_live_...)   [obligatoria]
+  PHARMADATE_API_URL       por defecto ${DEFAULT_API_URL}
+  PHARMADATE_PHARMACY_REF  CIF de la farmacia por defecto (solo partners)
+  PHARMADATE_MCP_MODE      READ_ONLY (defecto) | STANDARD
+`;
+function fail(mensaje) {
+    process.stderr.write(`pharmadate-mcp: ${scrubText(mensaje)}\n`);
+    process.exit(1);
+}
+async function runStdio() {
+    const apiKey = (process.env['PHARMADATE_API_KEY'] ?? '').trim();
+    if (!apiKey)
+        fail('falta PHARMADATE_API_KEY (tu key de partner pk_partner_... o de farmacia pk_live_...).');
+    let apiUrl;
+    try {
+        apiUrl = normalizeApiUrl(process.env['PHARMADATE_API_URL']);
+    }
+    catch (err) {
+        return fail(err instanceof Error ? err.message : 'PHARMADATE_API_URL no es valida.');
+    }
+    const mode = parseMode(process.env['PHARMADATE_MCP_MODE'], 'READ_ONLY');
+    const refCif = (process.env['PHARMADATE_PHARMACY_REF'] ?? '').trim();
+    const client = new PharmadateClient({ baseUrl: apiUrl, apiKey, userAgent: buildUserAgent(VERSION, 'stdio', undefined) });
+    let principal;
+    try {
+        principal = await detectPrincipal(client);
+    }
+    catch (err) {
+        if (err instanceof PrincipalError && err.kind === 'unauthorized')
+            fail('la API key no es valida, esta revocada o es de un tipo no admitido. Revisa PHARMADATE_API_KEY.');
+        return fail(`no se pudo comprobar la API key contra ${apiUrl}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const server = createPharmadateServer({
+        principal,
+        client,
+        credentialId: credentialId(apiKey),
+        mode,
+        limits: new McpLimits(),
+        transport: 'stdio',
+        defaultPharmacy: principal.role === 'partner' && refCif ? { cif: refCif } : undefined,
+    });
+    await server.connect(new StdioServerTransport());
+    logger.info({ role: principal.role, mode, apiUrl }, 'pharmadate-mcp (stdio) listo');
+}
+async function runHttp() {
+    const { default: express } = await import('express');
+    const { createMcpRouter } = await import('./http.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 { 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),
+    });
+    const app = express();
+    app.disable('x-powered-by');
+    app.use(router);
+    app.listen(port, () => logger.info({ port, publicUrl }, 'pharmadate-mcp (http) escuchando'));
+}
+const args = process.argv.slice(2);
+if (args.includes('--version') || args.includes('-v')) {
+    process.stdout.write(`${VERSION}\n`);
+}
+else if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(AYUDA);
+}
+else if (args.some((a) => a === '--transport=http' || a === '--http')) {
+    runHttp().catch((err) => fail(err instanceof Error ? err.message : String(err)));
+}
+else {
+    runStdio().catch((err) => fail(err instanceof Error ? err.message : String(err)));
+}