@pharmadate/mcp 0.0.0-stage → 0.1.1

package/dist/tools/partner.js

@@ -0,0 +1,176 @@
+/**
+ * Herramientas SOLO de partner: el CRUD de farmacias propias (`/api/v1/pharmacies`).
+ *
+ * Estas rutas no usan `X-Pharmacy-Ref` ni dan de alta nada por su cuenta: solo el partner dueno las ve y las toca.
+ * Una API key de farmacia da 403 en ellas, asi que ni siquiera se registran para ese rol.
+ *
+ * @module tools/partner
+ */
+import { z } from 'zod';
+import { ApiNetworkError } from '../client.js';
+import { apiErrorResult, applyKeyPolicy, errResult, networkErrorResult, okResult } from '../results.js';
+import { PARTNER_ONLY, READ_ANN } from './types.js';
+const REVEAL = z
+    .boolean()
+    .optional()
+    .describe('Si es true, la API key COMPLETA se entrega al usuario en un bloque aparte (audience: user). Por defecto (false) solo se ve el prefijo. ' +
+    'OJO: la key puede quedar en el historial del chat. Esta key solo se muestra esta vez.');
+const FARMACIA_ID = z.number().int().positive().describe('`id` de la farmacia en Pharmadate (el que devuelven listPharmacies / createPharmacy).');
+const COOPERATIVAS = z.array(z.enum(['BIDAFARMA', 'HEFAME', 'COFARES', 'ALLIANCE', 'OTROS', 'PHARMADATE']));
+const BILLING = z
+    .object({
+    direccion: z.string().min(1).max(255),
+    codigo_postal: z.string().min(1).max(255),
+    localidad: z.string().min(1).max(255),
+    ciudad: z.string().min(1).max(255).describe('Provincia.'),
+})
+    .nullable()
+    .describe('Direccion de FACTURACION si es distinta de la de entrega (los cuatro campos son obligatorios). null la quita (solo en updatePharmacy).');
+const txt = (max = 255) => z.string().min(1).max(max);
+/** Llamada del CRUD (sin farmacia que resolver) con traduccion de errores. */
+async function crud(ctx, req, errorCtx, onOk) {
+    try {
+        const res = await ctx.client.request(req);
+        if (!res.ok)
+            return apiErrorResult(res, errorCtx);
+        if (onOk)
+            return onOk(res.body, res.requestId, res.status);
+        return okResult(res.body, { request_id: res.requestId, http_status: res.status });
+    }
+    catch (err) {
+        if (err instanceof ApiNetworkError)
+            return networkErrorResult(err);
+        throw err;
+    }
+}
+export function partnerTools() {
+    return [
+        {
+            name: 'listPharmacies',
+            title: 'Listar mis farmacias',
+            description: 'Lista SOLO las farmacias de este partner (las de otros no existen para ti), con filtros por `cif`, `partner_pharmacy_id`, `active` y `updated_since`. ' +
+                'Incluye las dadas de baja (`active: false`). Usala para COMPROBAR un CIF o localizar el `id` de una farmacia antes de operar. Nunca devuelve la API key completa, solo su prefijo.',
+            op: 'READ',
+            http: { method: 'GET', path: '/api/v1/pharmacies' },
+            roles: PARTNER_ONLY,
+            annotations: READ_ANN,
+            inputSchema: {
+                page: z.number().int().min(1).optional(),
+                per_page: z.number().int().min(1).max(200).optional().describe('Maximo 200 (por defecto 50).'),
+                cif: z.string().max(20).optional().describe('CIF exacto.'),
+                partner_pharmacy_id: z.string().max(255).optional().describe('Tu identificador de la farmacia.'),
+                active: z.boolean().optional().describe('true solo activas, false solo dadas de baja.'),
+                updated_since: z.string().max(40).optional().describe('ISO 8601 (el `as_of` de una pasada anterior).'),
+            },
+            handler: async (args, ctx) => crud(ctx, { method: 'GET', path: '/v1/pharmacies', query: args }, {}),
+        },
+        {
+            name: 'getPharmacy',
+            title: 'Detalle de una farmacia',
+            description: 'Una farmacia propia por su `id`: datos, direccion de facturacion, estado (`active`) y prefijo de su API key. Una farmacia ajena responde como si no existiera.',
+            op: 'READ',
+            http: { method: 'GET', path: '/api/v1/pharmacies/{id}' },
+            roles: PARTNER_ONLY,
+            annotations: READ_ANN,
+            inputSchema: { id: FARMACIA_ID },
+            handler: async (args, ctx) => crud(ctx, { method: 'GET', path: `/v1/pharmacies/${args.id}` }, { pharmacyId: args.id }),
+        },
+        {
+            name: 'createPharmacy',
+            title: 'Dar de alta una farmacia',
+            description: 'Da de alta una farmacia nueva para este partner. El CIF es unico en TODA la plataforma y no se puede cambiar despues; el email tambien es unico. ' +
+                'Comprueba antes con listPharmacies que no existe ya. Devuelve la farmacia con su API key (por defecto solo el prefijo; con reveal_api_key=true la key completa va al usuario, que debe guardarla). ' +
+                'Confirma los datos con el usuario antes de crearla.',
+            op: 'WRITE',
+            http: { method: 'POST', path: '/api/v1/pharmacies' },
+            roles: PARTNER_ONLY,
+            annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+            inputSchema: {
+                cif: z.string().min(8).max(12).describe('CIF/NIF de la farmacia (8 a 12 letras o numeros, sin espacios).'),
+                nombre: txt(),
+                direccion: txt().describe('Direccion de ENTREGA del pedido.'),
+                codigo_postal: txt(),
+                localidad: txt(),
+                ciudad: txt().describe('Provincia.'),
+                email: z.string().email().max(255).describe('Unico: no puede usarlo otra farmacia.'),
+                telefono: txt().optional(),
+                cooperativas: COOPERATIVAS.optional().describe('Cooperativas con las que trabaja.'),
+                recargo_equivalencia: z.boolean().optional(),
+                partner_pharmacy_id: txt().optional().describe('Tu identificador de la farmacia (unico por partner).'),
+                billing: BILLING.optional(),
+                reveal_api_key: REVEAL,
+            },
+            handler: async (args, ctx) => {
+                const { reveal_api_key, ...body } = args;
+                return crud(ctx, { method: 'POST', path: '/v1/pharmacies', body }, {}, (b, rid, st) => applyKeyPolicy(b, reveal_api_key === true, { request_id: rid, http_status: st }));
+            },
+        },
+        {
+            name: 'updatePharmacy',
+            title: 'Modificar una farmacia',
+            description: 'Modifica datos de una farmacia propia y ACTIVA (solo los campos que envies). El CIF no se puede cambiar. `cooperativas` es la lista completa (vacia las quita) y `billing: null` quita la direccion de facturacion. ' +
+                'Muestra al usuario que vas a cambiar antes de hacerlo. Una farmacia de baja no se puede modificar: reactivala antes.',
+            op: 'WRITE',
+            http: { method: 'PATCH', path: '/api/v1/pharmacies/{id}' },
+            roles: PARTNER_ONLY,
+            annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+            inputSchema: {
+                id: FARMACIA_ID,
+                nombre: txt().optional(),
+                direccion: txt().optional().describe('Direccion de ENTREGA.'),
+                codigo_postal: txt().optional(),
+                localidad: txt().optional(),
+                ciudad: txt().optional().describe('Provincia.'),
+                email: z.string().email().max(255).optional(),
+                telefono: txt().optional(),
+                cooperativas: COOPERATIVAS.optional(),
+                recargo_equivalencia: z.boolean().optional(),
+                partner_pharmacy_id: txt().optional(),
+                billing: BILLING.optional(),
+            },
+            handler: async (args, ctx) => {
+                const { id, ...cambios } = args;
+                if (Object.values(cambios).every((v) => v === undefined)) {
+                    return errResult('Indica al menos un campo a modificar.', { error_code: 'invalid_request' });
+                }
+                return crud(ctx, { method: 'PATCH', path: `/v1/pharmacies/${id}`, body: cambios }, { pharmacyId: id });
+            },
+        },
+        {
+            name: 'deactivatePharmacy',
+            title: 'Dar de baja una farmacia',
+            description: 'Da de baja una farmacia propia (baja LOGICA): deja de poder operar y su API key actual se BORRA; los pedidos y albaranes se conservan y el CIF queda bloqueado. ' +
+                'Se deshace con reactivatePharmacy (con una API key nueva). Es idempotente. Pide confirmacion explicita al usuario antes de ejecutarla.',
+            op: 'DELETE',
+            http: { method: 'DELETE', path: '/api/v1/pharmacies/{id}' },
+            roles: PARTNER_ONLY,
+            annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+            inputSchema: { id: FARMACIA_ID },
+            handler: async (args, ctx) => crud(ctx, { method: 'DELETE', path: `/v1/pharmacies/${args.id}` }, { pharmacyId: args.id }),
+        },
+        {
+            name: 'reactivatePharmacy',
+            title: 'Reactivar una farmacia de baja',
+            description: 'Reactiva una farmacia propia dada de baja (deshace deactivatePharmacy). Genera una API key NUEVA (la de antes se borro). ' +
+                'Si ya estaba activa responde pharmacy_active sin tocar nada. Con reveal_api_key=true la key completa va al usuario; sin el, solo veras el prefijo y la key no se muestra en ningun otro sitio (tendrias que rotarla).',
+            op: 'WRITE',
+            http: { method: 'POST', path: '/api/v1/pharmacies/{id}/reactivate' },
+            roles: PARTNER_ONLY,
+            annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+            inputSchema: { id: FARMACIA_ID, reveal_api_key: REVEAL },
+            handler: async (args, ctx) => crud(ctx, { method: 'POST', path: `/v1/pharmacies/${args.id}/reactivate`, body: {} }, { pharmacyId: args.id }, (b, rid, st) => applyKeyPolicy(b, args.reveal_api_key === true, { request_id: rid, http_status: st })),
+        },
+        {
+            name: 'rotatePharmacyApiKey',
+            title: 'Rotar la API key de una farmacia',
+            description: 'Genera una API key NUEVA para una farmacia activa e INVALIDA LA ANTERIOR EN EL ACTO (cualquier integracion que la use dejara de funcionar). ' +
+                'Sirve para recuperar una key perdida. Pide confirmacion explicita al usuario. Usa reveal_api_key=true para que la key nueva llegue al usuario: sin ese flag la key nueva NO se muestra en ningun sitio y la anterior ya no vale.',
+            op: 'DELETE',
+            http: { method: 'POST', path: '/api/v1/pharmacies/{id}/api-key' },
+            roles: PARTNER_ONLY,
+            annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+            inputSchema: { id: FARMACIA_ID, reveal_api_key: REVEAL },
+            handler: async (args, ctx) => crud(ctx, { method: 'POST', path: `/v1/pharmacies/${args.id}/api-key`, body: {} }, { pharmacyId: args.id }, (b, rid, st) => applyKeyPolicy(b, args.reveal_api_key === true, { request_id: rid, http_status: st })),
+        },
+    ];
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tipos compartidos de las herramientas.
+ *
+ * Cada herramienta tiene el nombre de su `operationId` en frontend/api-docs/openapi.yaml, y declara su metodo y ruta
+ * (`http`) para que el test de contrato compruebe que coinciden con el OpenAPI.
+ *
+ * @module tools/types
+ */
+import type { ZodRawShape } from 'zod';
+import type { CallToolResult, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+import type { PharmadateClient } from '../client.js';
+import type { Principal, Role } from '../principal.js';
+import type { PharmacyRefArg } from '../pharmacy-resolver.js';
+import type { OperationType } from '../operation-mode.js';
+export interface ToolContext {
+    client: PharmadateClient;
+    principal: Principal;
+    /** Farmacia por defecto (stdio con PHARMADATE_PHARMACY_REF): se usa si la herramienta no recibe `pharmacy`. */
+    defaultPharmacy?: PharmacyRefArg | undefined;
+}
+export interface ToolDef {
+    /** = operationId del OpenAPI. */
+    name: string;
+    title: string;
+    description: string;
+    op: OperationType;
+    /** Metodo y ruta del OpenAPI (con `{id}`): lo verifica el test de contrato. */
+    http: {
+        method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+        path: string;
+    };
+    roles: readonly Role[];
+    annotations: ToolAnnotations;
+    inputSchema: ZodRawShape;
+    handler: (args: any, ctx: ToolContext) => Promise<CallToolResult>;
+}
+export declare const BOTH_ROLES: readonly Role[];
+export declare const PARTNER_ONLY: readonly Role[];
+export declare const READ_ANN: ToolAnnotations;

package/dist/tools/types.js

@@ -0,0 +1,3 @@
+export const BOTH_ROLES = ['partner', 'pharmacy'];
+export const PARTNER_ONLY = ['partner'];
+export const READ_ANN = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,15 @@
+/**
+ * Version del paquete, leida de package.json (esta un nivel por encima de `src/` y de `dist/`).
+ * @module version
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export const VERSION = (() => {
+    try {
+        const ruta = fileURLToPath(new URL('../package.json', import.meta.url));
+        return JSON.parse(readFileSync(ruta, 'utf-8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+})();

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@pharmadate/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "mcpName": "es.pharmadatepedido/mcp",
+  "version": "0.1.1",
+  "description": "Servidor MCP de Pharmadate: consulta el catalogo, valora y cursa pedidos y gestiona las farmacias de un partner desde Claude, ChatGPT, Cursor o cualquier cliente MCP. 19 herramientas sobre la API v1, stdio, Streamable HTTP y OAuth 2.1.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "pharmadate-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "server.json"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "author": {
+    "name": "Nubiia",
+    "email": "samuel.fraga@nubiia.es",
+    "url": "https://nubiia.es"
+  },
+  "license": "MIT",
+  "homepage": "https://www.pharmadatepedido.es/api-docs/mcp.html",
+  "bugs": {
+    "email": "samuel.fraga@nubiia.es"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rubenga11/pedido-directo.git",
+    "directory": "mcp"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pharmadate",
+    "pharmacy",
+    "farmacia",
+    "topfarma",
+    "claude",
+    "chatgpt"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run --exclude '**/integration/**'",
+    "test:integration": "vitest run integration/",
+    "test:all": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "express": "^4.21.0",
+    "pino": "^10.3.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "js-yaml": "^4.1.0",
+    "tsx": "^4.6.0",
+    "typescript": "^5.3.0",
+    "undici": "^7.0.0",
+    "vitest": "^2.1.8",
+    "zod-to-json-schema": "^3.25.2"
+  }
+}

package/server.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "es.pharmadatepedido/mcp",
+  "title": "Pharmadate",
+  "description": "Pharmadate: catalogo, valoracion y pedidos de farmacia, y gestion de farmacias para partners.",
+  "version": "0.1.1",
+  "websiteUrl": "https://www.pharmadatepedido.es/api-docs/mcp.html",
+  "repository": {
+    "url": "https://github.com/Rubenga11/pedido-directo",
+    "source": "github",
+    "subfolder": "mcp"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "@pharmadate/mcp",
+      "version": "0.1.1",
+      "runtimeHint": "npx",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "PHARMADATE_API_KEY",
+          "description": "API key de Pharmadate: de partner (pk_partner_...) o de farmacia (pk_live_...)",
+          "isRequired": true,
+          "isSecret": true
+        },
+        {
+          "name": "PHARMADATE_MCP_MODE",
+          "description": "READ_ONLY (por defecto: solo lectura y valoracion) o STANDARD (permite pedidos y gestion de farmacias)",
+          "isRequired": false,
+          "default": "READ_ONLY",
+          "choices": ["READ_ONLY", "STANDARD"]
+        },
+        {
+          "name": "PHARMADATE_PHARMACY_REF",
+          "description": "Solo partners: CIF de la farmacia con la que operar por defecto",
+          "isRequired": false
+        },
+        {
+          "name": "PHARMADATE_API_URL",
+          "description": "URL de la API (por defecto https://www.pharmadatepedido.es/api)",
+          "isRequired": false
+        }
+      ]
+    }
+  ],
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://www.pharmadatepedido.es/mcp"
+    }
+  ]
+}