@pharmadate/mcp 0.0.0-stage → 0.1.1

package/dist/auth/oauth-provider.js

@@ -0,0 +1,208 @@
+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;
+export const CHAIN_MAX_S = 90 * 24 * 3_600;
+const MAX_REDIRECT_URIS = 10;
+const MAX_REDIRECT_URI_LENGTH = 512;
+const nowS = () => Math.floor(Date.now() / 1000);
+/** DCR sin base de datos: el client_id lleva la metadata firmada. Todos los clientes son publicos (PKCE, sin secreto). */
+export class StatelessClientsStore {
+    keys;
+    constructor(keys) {
+        this.keys = keys;
+    }
+    getClient(clientId) {
+        const meta = verify(clientId, this.keys);
+        if (!meta || !Array.isArray(meta.redirect_uris))
+            return undefined;
+        return {
+            client_id: clientId,
+            client_id_issued_at: meta.iat,
+            redirect_uris: meta.redirect_uris,
+            client_name: meta.client_name,
+            grant_types: meta.grant_types,
+            response_types: meta.response_types,
+            token_endpoint_auth_method: 'none',
+            scope: meta.scope,
+        };
+    }
+    registerClient(client) {
+        const uris = (client.redirect_uris ?? []).map(String);
+        if (uris.length === 0 || uris.length > MAX_REDIRECT_URIS || uris.some((u) => u.length > MAX_REDIRECT_URI_LENGTH)) {
+            throw new InvalidRequestError(`redirect_uris: entre 1 y ${MAX_REDIRECT_URIS} URLs de hasta ${MAX_REDIRECT_URI_LENGTH} caracteres.`);
+        }
+        const meta = {
+            redirect_uris: uris,
+            grant_types: ['authorization_code', 'refresh_token'],
+            response_types: ['code'],
+            token_endpoint_auth_method: 'none',
+            iat: nowS(),
+        };
+        if (client.client_name)
+            meta.client_name = String(client.client_name).slice(0, 100);
+        if (client.scope)
+            meta.scope = String(client.scope).slice(0, 100);
+        const clientId = sign(meta, this.keys);
+        return { ...this.getClient(clientId) };
+    }
+}
+export class PharmadateOAuthProvider {
+    clientsStore;
+    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 (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,
+            scope: params.scopes?.join(' '),
+            state: params.state,
+            resource: params.resource?.toString(),
+            clientName: client.client_name,
+        }));
+    }
+    /**
+     * 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), 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' || !redirectIsRegistered(form.redirect_uri, client.redirect_uris.map(String))) {
+            res.status(400).type('text/plain').send('Cliente o redirect_uri no validos.');
+            return;
+        }
+        const challenge = form.code_challenge ?? '';
+        if (!/^[A-Za-z0-9_-]{43,128}$/.test(challenge)) {
+            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,
+                scope: form.scope,
+                state: form.state,
+                resource: form.resource,
+                clientName: client.client_name,
+                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.');
+            return;
+        }
+        const check = await this.validateKey(apiKey);
+        if (!check.ok) {
+            volver(check.reason === 'invalid' ? 'La API key no es valida, esta revocada o es de un tipo no admitido. Revisala y vuelve a intentarlo.' : 'No se ha podido comprobar la API key ahora mismo. Vuelve a intentarlo en un momento.');
+            return;
+        }
+        const scopes = (form.scope ?? '').split(' ').filter(Boolean);
+        const payload = {
+            k: apiKey,
+            cid: client.client_id,
+            ru: form.redirect_uri,
+            cc: challenge,
+            sc: scopes.length ? scopes : [SCOPE],
+            exp: nowS() + CODE_TTL_S,
+            ...(form.resource ? { res: form.resource } : {}),
+        };
+        const code = seal('code', payload, this.keys);
+        const destino = new URL(form.redirect_uri);
+        destino.searchParams.set('code', code);
+        if (form.state)
+            destino.searchParams.set('state', form.state);
+        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) {
+        const c = open('code', authorizationCode, this.keys);
+        if (!c || c.exp < nowS() || c.cid !== client.client_id)
+            throw new InvalidGrantError('Codigo de autorizacion invalido o caducado.');
+        return c.cc;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
+        const c = open('code', authorizationCode, this.keys);
+        if (!c || c.exp < nowS())
+            throw new InvalidGrantError('Codigo de autorizacion invalido o caducado.');
+        if (c.cid !== client.client_id)
+            throw new InvalidGrantError('El codigo no se emitio para este cliente.');
+        if (redirectUri && redirectUri !== c.ru)
+            throw new InvalidGrantError('redirect_uri no coincide con el de la autorizacion.');
+        return this.issue(c.k, client.client_id, c.sc, resource?.toString() ?? c.res, nowS());
+    }
+    async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+        const r = open('refresh', refreshToken, this.keys);
+        if (!r || r.exp < nowS())
+            throw new InvalidGrantError('Refresh token invalido o caducado.');
+        if (r.cid !== client.client_id)
+            throw new InvalidGrantError('El refresh token no se emitio para este cliente.');
+        if (nowS() - r.cs > CHAIN_MAX_S)
+            throw new InvalidGrantError('La sesion ha superado su vida maxima; vuelve a iniciar sesion.');
+        if (scopes?.length && scopes.some((s) => !r.sc.includes(s)))
+            throw new InvalidGrantError('Los scopes pedidos no son un subconjunto de los concedidos.');
+        // Si la key se ha rotado o revocado, no se renueva: el cliente tiene que volver a autorizar
+        const check = await this.validateKey(r.k);
+        if (!check.ok) {
+            if (check.reason === 'invalid')
+                throw new InvalidGrantError('La API key ya no es valida; vuelve a iniciar sesion.');
+            throw new ServerError('No se pudo comprobar la API key; reintenta.');
+        }
+        return this.issue(r.k, client.client_id, scopes?.length ? scopes : r.sc, resource?.toString() ?? r.res, r.cs);
+    }
+    /** Descifra un access token. Lo usa `requireBearerAuth` del SDK. */
+    async verifyAccessToken(token) {
+        const a = open('access', token, this.keys);
+        if (!a)
+            throw new InvalidTokenError('Token invalido.');
+        if (a.exp < nowS())
+            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);
+        return info;
+    }
+    issue(apiKey, clientId, scopes, resource, chainStart) {
+        const now = nowS();
+        const base = { k: apiKey, cid: clientId, sc: scopes, ...(resource ? { res: resource } : {}) };
+        const access = seal('access', { ...base, exp: now + ACCESS_TTL_S }, this.keys);
+        const refresh = seal('refresh', { ...base, exp: Math.min(now + REFRESH_TTL_S, chainStart + CHAIN_MAX_S), cs: chainStart }, this.keys);
+        return { access_token: access, token_type: 'bearer', expires_in: ACCESS_TTL_S, scope: scopes.join(' '), refresh_token: refresh };
+    }
+}

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/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,79 @@
+/**
+ * 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';
+/** 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 {
+    /** 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;
+    /**
+     * 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;
+}
+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;