@pharmadate/mcp 0.0.0-stage → 0.1.1

package/dist/http.js

@@ -0,0 +1,272 @@
+/**
+ * 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, 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'];
+/**
+ * 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 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]'];
+    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,
+        ...(options.trustedRedirects ? { trustedRedirects: options.trustedRedirects } : {}),
+    });
+    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 ip = clientIp(req, hops);
+        const bearer = extractBearer(req.headers.authorization);
+        if (!bearer) {
+            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 rechazar('Token emitido para otro recurso.');
+                }
+                apiKey = String(info.extra.apiKey);
+                viaOAuth = true;
+            }
+            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 rechazar('Credencial no reconocida.');
+        }
+        if (!viaOAuth && bloqueada && !cache.get(credentialId(apiKey)))
+            return demasiados();
+        const client = newClient(apiKey, req);
+        let principal;
+        try {
+            principal = await cache.resolve(apiKey, client);
+        }
+        catch (err) {
+            if (err instanceof PrincipalError && err.kind === 'unauthorized')
+                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;
+        }
+        // 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();
+        });
+        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,114 @@
+#!/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 { 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'] ?? '';
+    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');
+    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)));
+}

package/dist/limits.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Limites propios del MCP, por credencial (sha256 de la key). Se suman a los de la API (120 peticiones/min).
+ *
+ *   - 30 escrituras por hora (`createOrder`, `createPharmacy`, `updatePharmacy`, `deactivatePharmacy`,
+ *     `reactivatePharmacy`, `rotatePharmacyApiKey`)
+ *   - 10 `createOrder` por hora
+ *   - 500 lineas como maximo por quote/pedido (lo comprueba el esquema de la herramienta)
+ *
+ * Los contadores viven en memoria del proceso: un reinicio los pone a cero y, con varias instancias detras del
+ * balanceador, cada una tiene el suyo. Para lo que protegen (una conversacion desbocada o inyectada que lance
+ * escrituras sin freno) es suficiente. Una llamada rechazada no alarga la ventana.
+ *
+ * @module limits
+ */
+export declare const MAX_LINES = 500;
+export declare const DEFAULT_WRITES_PER_HOUR = 30;
+export declare const DEFAULT_ORDERS_PER_HOUR = 10;
+export type RateLimitResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    retryAfterSeconds: number;
+};
+/** Ventana deslizante por clave. */
+export declare class WriteRateLimiter {
+    readonly max: number;
+    private readonly windowMs;
+    private readonly now;
+    private readonly hits;
+    constructor(max: number, windowMs?: number, now?: () => number);
+    tryConsume(key: string): RateLimitResult;
+    /** Purga periodica de claves vencidas. El temporizador no mantiene vivo el proceso. */
+    startPurgeTimer(intervalMs?: number): () => void;
+    get size(): number;
+    private purge;
+}
+/** Los dos contadores de escritura. Una instancia por proceso (no por peticion). */
+export declare class McpLimits {
+    readonly writes: WriteRateLimiter;
+    readonly orders: WriteRateLimiter;
+    constructor(opts?: {
+        writesPerHour?: number;
+        ordersPerHour?: number;
+        now?: () => number;
+    });
+    /**
+     * Consume una escritura (y un pedido si `isOrder`). Devuelve el mensaje de rechazo, o `null` si puede seguir.
+     */
+    check(credentialId: string, isOrder: boolean): string | null;
+    startPurgeTimers(): () => void;
+}
+/** 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, 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

@@ -0,0 +1,152 @@
+/**
+ * Limites propios del MCP, por credencial (sha256 de la key). Se suman a los de la API (120 peticiones/min).
+ *
+ *   - 30 escrituras por hora (`createOrder`, `createPharmacy`, `updatePharmacy`, `deactivatePharmacy`,
+ *     `reactivatePharmacy`, `rotatePharmacyApiKey`)
+ *   - 10 `createOrder` por hora
+ *   - 500 lineas como maximo por quote/pedido (lo comprueba el esquema de la herramienta)
+ *
+ * Los contadores viven en memoria del proceso: un reinicio los pone a cero y, con varias instancias detras del
+ * balanceador, cada una tiene el suyo. Para lo que protegen (una conversacion desbocada o inyectada que lance
+ * escrituras sin freno) es suficiente. Una llamada rechazada no alarga la ventana.
+ *
+ * @module limits
+ */
+export const MAX_LINES = 500;
+export const DEFAULT_WRITES_PER_HOUR = 30;
+export const DEFAULT_ORDERS_PER_HOUR = 10;
+const HOUR_MS = 3_600_000;
+const PURGE_THRESHOLD = 5_000;
+/** Ventana deslizante por clave. */
+export class WriteRateLimiter {
+    max;
+    windowMs;
+    now;
+    hits = new Map();
+    constructor(max, windowMs = HOUR_MS, now = Date.now) {
+        this.max = max;
+        this.windowMs = windowMs;
+        this.now = now;
+    }
+    tryConsume(key) {
+        const now = this.now();
+        if (this.hits.size > PURGE_THRESHOLD)
+            this.purge(now);
+        const recent = (this.hits.get(key) ?? []).filter((t) => now - t < this.windowMs);
+        if (recent.length >= this.max) {
+            this.hits.set(key, recent);
+            const retryAfterMs = recent[0] + this.windowMs - now;
+            return { allowed: false, retryAfterSeconds: Math.max(1, Math.ceil(retryAfterMs / 1000)) };
+        }
+        recent.push(now);
+        this.hits.set(key, recent);
+        return { allowed: true };
+    }
+    /** Purga periodica de claves vencidas. El temporizador no mantiene vivo el proceso. */
+    startPurgeTimer(intervalMs = 600_000) {
+        const timer = setInterval(() => this.purge(this.now()), intervalMs);
+        timer.unref();
+        return () => clearInterval(timer);
+    }
+    get size() {
+        return this.hits.size;
+    }
+    purge(now) {
+        for (const [k, ts] of this.hits) {
+            if (ts.every((t) => now - t >= this.windowMs))
+                this.hits.delete(k);
+        }
+    }
+}
+/** Los dos contadores de escritura. Una instancia por proceso (no por peticion). */
+export class McpLimits {
+    writes;
+    orders;
+    constructor(opts = {}) {
+        this.writes = new WriteRateLimiter(opts.writesPerHour ?? DEFAULT_WRITES_PER_HOUR, HOUR_MS, opts.now);
+        this.orders = new WriteRateLimiter(opts.ordersPerHour ?? DEFAULT_ORDERS_PER_HOUR, HOUR_MS, opts.now);
+    }
+    /**
+     * Consume una escritura (y un pedido si `isOrder`). Devuelve el mensaje de rechazo, o `null` si puede seguir.
+     */
+    check(credentialId, isOrder) {
+        if (isOrder) {
+            const o = this.orders.tryConsume(credentialId);
+            if (!o.allowed) {
+                return `Limite de pedidos alcanzado: como maximo ${this.orders.max} createOrder por hora y credencial. No se ha enviado nada. Reintenta en unos ${Math.ceil(o.retryAfterSeconds / 60)} minuto(s).`;
+            }
+        }
+        const w = this.writes.tryConsume(credentialId);
+        if (!w.allowed) {
+            return `Limite de escrituras alcanzado: como maximo ${this.writes.max} operaciones de escritura por hora y credencial. No se ha ejecutado nada. Reintenta en unos ${Math.ceil(w.retryAfterSeconds / 60)} minuto(s).`;
+        }
+        return null;
+    }
+    startPurgeTimers() {
+        const a = this.writes.startPurgeTimer();
+        const b = this.orders.startPurgeTimer();
+        return () => {
+            a();
+            b();
+        };
+    }
+}
+/** 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, maxEntries = DEFAULT_IP_LIMITER_ENTRIES) {
+        this.max = max;
+        this.windowMs = windowMs;
+        this.now = now;
+        this.maxEntries = maxEntries;
+    }
+    /** `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) {
+            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);
+        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);
+        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

@@ -0,0 +1,10 @@
+/**
+ * Logger estructurado (pino). Siempre a stderr: en stdio el stdout es el canal del protocolo y no se puede ensuciar.
+ * Todo lo que pasa por aqui se redacta con {@link scrubDeep}: una key o un token no llegan nunca al log.
+ *
+ * @module logger
+ */
+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

@@ -0,0 +1,34 @@
+/**
+ * Logger estructurado (pino). Siempre a stderr: en stdio el stdout es el canal del protocolo y no se puede ensuciar.
+ * Todo lo que pasa por aqui se redacta con {@link scrubDeep}: una key o un token no llegan nunca al log.
+ *
+ * @module logger
+ */
+import pino from 'pino';
+import { scrubDeep, scrubText } from './scrub.js';
+import { VERSION } from './version.js';
+const nivel = process.env['LOG_LEVEL'] ?? 'info';
+/** 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]',
+        },
+        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 }));