@coinpaprika/mcp 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to the CoinPaprika MCP Server will be documented in this fil
 
 ## [Unreleased]
 
+## [1.4.2] - 2026-10-21
+
+### Security
+
+- **Ids are checked against the characters real ids use.** 1.4.1 refused a short list of bad characters, so an id such as `..;`, `.. ` or a Unicode look-alike of `.` or `/` still reached the API, and whether it then meant `..` depended on how each server in front of the API parsed it. `exchangeId`, `tagId`, `personId` and `platformId` must now match `[a-z0-9-]`, and `contractAddress` `[A-Za-z0-9._~:-]` and not only dots (EVM, Solana, Sui and Aptos type tags such as `0x2::sui::SUI`, dotted NEAR and Hedera ids, TON addresses). Every path segment is checked against the same alphabet, and only the routes the tools call are sent. Anything else is refused with "Invalid identifier" before a request is made.
+- **Redirects from the API are no longer followed blindly.** fetch followed them by default, repeating the request with your key without the path check seeing the new URL. A redirect is now followed only on the same host and base path, to the same route as the original request, and at most three times; anything else returns `CP502_REDIRECT_REFUSED`.
+- **`keyInfo` passes only named fields to the model.** It returned the whole `/key/info` answer. It now returns `plan`, `plan_status`, `plan_started_at` and the `usage` message and monthly `requests_made` / `requests_left` counters, and drops every other field, including `portal_url`, and any value that contains the key.
+
+## [1.4.1] - 2026-10-21
+
+### Security
+
+- **An id could change which API path a tool called.** Ids go into the request path through `encodeURIComponent`, which leaves `.` and `..` as they are, so an id of `..` moved the request, with your API key on it, to a different path. Every request now has its path checked before it is sent: a path that changes when parsed, or a segment that decodes to `.` or `..` or holds `/`, `\` or `%`, is refused with "Invalid identifier". No real coin, exchange, tag, person, platform or contract id is affected.
+
 ## [1.4.0] - 2026-08-19
 
 ### Fixed

package/dist/index.js

@@ -2,6 +2,8 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createRequire } from 'module';
 import fetch from 'node-fetch';
+import { assertPathUnchanged, CONTRACT_ADDRESS, fetchUpstream, SLUG_ID, upstreamRoute } from './safe-path.js';
+import { pickKeyInfo } from './key-info.js';
 import { z } from 'zod';
 
 // Server version, read from package.json so the banner, capabilities
@@ -28,6 +30,7 @@ const ErrorCodes = {
   CP404_NOT_FOUND: "CP404_NOT_FOUND",
   CP429_RATE_LIMIT: "CP429_RATE_LIMIT",
   CP500_SERVER_ERROR: "CP500_SERVER_ERROR",
+  CP502_REDIRECT_REFUSED: "CP502_REDIRECT_REFUSED",
   CP_UNKNOWN_ERROR: "CP_UNKNOWN_ERROR",
 };
 
@@ -195,7 +198,25 @@ function clamp(n, min, max) {
 // Helper function to fetch data from CoinPaprika API with structured error handling
 async function fetchFromAPI(endpoint) {
   const startTime = Date.now();
-  const response = await fetch(`${API_BASE_URL}${endpoint}`, { headers: buildHeaders() });
+  const url = `${API_BASE_URL}${endpoint}`;
+  assertPathUnchanged(url); // before the key leaves the process
+  if (upstreamRoute(API_BASE_URL, url) === -1) throw new Error('Invalid identifier.');
+  let response;
+  try {
+    response = await fetchUpstream(fetch, API_BASE_URL, url, { headers: buildHeaders() });
+  } catch (e) {
+    if (e && e.status >= 300 && e.status <= 399) {
+      throw buildErrorResponse(
+        ErrorCodes.CP502_REDIRECT_REFUSED,
+        e.message,
+        false,
+        'Try again later. If it persists, report it at https://github.com/coinpaprika/coinpaprika-mcp/issues',
+        undefined,
+        { endpoint, status: e.status }
+      );
+    }
+    throw e;
+  }
 
   if (!response.ok) {
     const structuredError = parseAPIError(response.status, response.statusText, endpoint);
@@ -744,13 +765,38 @@ const server = new McpServer({
 // (coinId / baseCurrencyId / quoteCurrencyId) instead of repeating it in each
 // handler, so a ticker symbol like "BTC" gets actionable guidance to call
 // search/resolveId instead of a bare upstream 404.
+// The other ids that go into a request path are checked the same way: only the characters real
+// ids use, so a value that is not an id never becomes part of a URL.
+const OTHER_ID_FORMATS = {
+  exchangeId: SLUG_ID,
+  tagId: SLUG_ID,
+  personId: SLUG_ID,
+  platformId: SLUG_ID,
+  contractAddress: CONTRACT_ADDRESS,
+};
+
+function invalidIdError(field, value) {
+  const allowed = field === 'contractAddress'
+    ? 'letters, digits, ".", "_", "~", ":" and "-"'
+    : 'lowercase letters, digits and "-"';
+  return buildErrorResponse(
+    ErrorCodes.CP400_BAD_REQUEST,
+    `Invalid identifier: ${field} may contain only ${allowed}.`,
+    false,
+    'Pass the id exactly as CoinPaprika returns it, e.g. from search, getExchanges, getTags, getPlatforms or getContracts.',
+    undefined,
+    { field, length: value.length }
+  );
+}
+
 const _registerTool = server.tool.bind(server);
 server.tool = (...regArgs) => {
   const handler = regArgs[regArgs.length - 1];
   const schema = regArgs.length >= 4 && regArgs[2] && typeof regArgs[2] === 'object' ? regArgs[2] : null;
   if (typeof handler === 'function' && schema) {
     const idFields = ['coinId', 'baseCurrencyId', 'quoteCurrencyId'].filter((f) => f in schema);
-    if (idFields.length > 0) {
+    const otherIdFields = Object.keys(OTHER_ID_FORMATS).filter((f) => f in schema);
+    if (idFields.length > 0 || otherIdFields.length > 0) {
       regArgs[regArgs.length - 1] = async (args, ...rest) => {
         for (const f of idFields) {
           const v = args && args[f];
@@ -759,6 +805,12 @@ server.tool = (...regArgs) => {
             if (err) return formatMcpError(err);
           }
         }
+        for (const f of otherIdFields) {
+          const v = args && args[f];
+          if (typeof v === 'string' && !OTHER_ID_FORMATS[f].test(v)) {
+            return formatMcpError(invalidIdError(f, v));
+          }
+        }
         return handler(args, ...rest);
       };
     }
@@ -1305,7 +1357,11 @@ server.tool(
       });
     }
     return withGuidance(
-      () => fetchFromAPI('/key/info'),
+      async () => {
+        // Only named, non-secret fields reach the model, whatever else the API sends.
+        const { data, meta } = await fetchFromAPI('/key/info');
+        return { data: pickKeyInfo(data, API_KEY), meta };
+      },
       'keyInfo requires a Pro plan API key.'
     );
   }

package/dist/key-info.js

@@ -0,0 +1,43 @@
+// keyInfo hands the account's /key/info answer to the model. The model is not the key owner,
+// so only fields named here pass, each with the type it is documented to have: the plan, its
+// status and start date, and the monthly request counters. Anything else the API adds later,
+// such as a key, a customer id or a per-account portal link, is dropped.
+
+const STRING_FIELDS = ['plan', 'plan_status', 'plan_started_at'];
+const MAX_STRING = 64;
+
+function safeString(value, apiKey) {
+  if (typeof value !== 'string' || value.length > MAX_STRING) return undefined;
+  if (apiKey && value.includes(apiKey)) return undefined;
+  return value;
+}
+
+function safeNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+export function pickKeyInfo(body, apiKey) {
+  const out = {};
+  if (!body || typeof body !== 'object') return out;
+  for (const field of STRING_FIELDS) {
+    const v = safeString(body[field], apiKey);
+    if (v !== undefined) out[field] = v;
+  }
+  const usage = body.usage;
+  if (usage && typeof usage === 'object') {
+    const picked = {};
+    const message = safeString(usage.message, apiKey);
+    if (message !== undefined) picked.message = message;
+    const month = usage.current_month;
+    if (month && typeof month === 'object') {
+      const counters = {};
+      for (const field of ['requests_made', 'requests_left']) {
+        const v = safeNumber(month[field]);
+        if (v !== undefined) counters[field] = v;
+      }
+      picked.current_month = counters;
+    }
+    out.usage = picked;
+  }
+  return out;
+}

package/dist/safe-path.js

@@ -0,0 +1,100 @@
+// Ids reach the upstream path through encodeURIComponent, which encodes "/", "?" and "#" but
+// leaves "." and "..". An id of ".." would make the request, with your API key on it, go to a
+// different path than the tool intended, because URL parsing resolves dot segments. And a
+// character that URL parsing leaves alone can still mean "." or "/" to a server that strips
+// ";" parameters, trims whitespace or folds Unicode before routing. So ids are checked against
+// the characters real ids use (an allowlist, not a list of bad characters), every path segment
+// is checked against the same alphabet, and a URL whose path changes when parsed is refused.
+
+// Exchange, tag, person and platform ids: "binance", "defi", "vitalik-buterin", "eth-ethereum".
+export const SLUG_ID = /^[a-z0-9-]+$/;
+// Contract addresses: EVM 0x hex, Solana base58, Sui and Aptos type tags ("0x2::sui::SUI"),
+// dotted forms such as NEAR or Hedera ids, TON base64url. Never only dots.
+export const CONTRACT_ADDRESS = /^(?!\.+$)[A-Za-z0-9._~:-]+$/;
+// Any path segment once decoded: the union of the id alphabets and the fixed route words.
+const SEGMENT = CONTRACT_ADDRESS;
+
+// The routes the tools call, relative to the base URL. "S" is one segment.
+const S = '[^/]+';
+const ROUTES = [
+  '/global', '/coins', '/tickers', '/tags', '/exchanges', '/contracts', '/search', '/price-converter',
+  '/key/info', '/changelog/ids',
+  `/coins/${S}`, `/coins/${S}/(events|exchanges|markets)`, `/coins/${S}/ohlcv/(latest|today|historical)`,
+  `/tickers/${S}`, `/tickers/${S}/historical`,
+  `/people/${S}`, `/tags/${S}`, `/exchanges/${S}`, `/exchanges/${S}/markets`,
+  `/contracts/${S}`, `/contracts/${S}/${S}`, `/contracts/${S}/${S}/historical`,
+].map((r) => new RegExp(`^${r}$`));
+
+export function assertPathUnchanged(url) {
+  const afterScheme = url.indexOf('://');
+  const pathStart = afterScheme === -1 ? -1 : url.indexOf('/', afterScheme + 3);
+  if (pathStart === -1) return;
+  const end = url.slice(pathStart).search(/[?#]/);
+  const rawPath = end === -1 ? url.slice(pathStart) : url.slice(pathStart, pathStart + end);
+  if (new URL(url).pathname !== rawPath) {
+    throw new Error('Invalid identifier: an id may not be "." or "..".');
+  }
+  for (const seg of rawPath.split('/').slice(1)) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(seg);
+    } catch {
+      throw new Error('Invalid identifier.');
+    }
+    if (!SEGMENT.test(decoded)) {
+      throw new Error('Invalid identifier.');
+    }
+  }
+}
+
+// Index of the route a URL under baseUrl calls, or -1 if it is not one the tools use.
+export function upstreamRoute(baseUrl, url) {
+  try {
+    const base = new URL(baseUrl);
+    const target = new URL(url);
+    const basePath = base.pathname.replace(/\/$/, '');
+    if (target.origin !== base.origin || !target.pathname.startsWith(`${basePath}/`)) return -1;
+    const path = target.pathname.slice(basePath.length);
+    return ROUTES.findIndex((re) => re.test(path));
+  } catch {
+    return -1;
+  }
+}
+
+// Where a redirect from the API may be followed, or null when it may not. The key is on every
+// request, so a hop must stay on the same origin and base path, call the same route as the
+// request it answers (a redirect may change an id, not which resource is read), and pass the
+// same path check as the first URL.
+export function upstreamRedirectTarget(baseUrl, currentUrl, location) {
+  if (!location) return null;
+  try {
+    const next = new URL(location, currentUrl);
+    next.hash = '';
+    const route = upstreamRoute(baseUrl, next.href);
+    if (route === -1 || route !== upstreamRoute(baseUrl, currentUrl)) return null;
+    assertPathUnchanged(next.href);
+    return next.href;
+  } catch {
+    return null;
+  }
+}
+
+// fetch with redirects handled here instead of by fetch, which would repeat the request, key
+// included, to wherever Location points. Returns the final response; throws on a refused hop.
+export async function fetchUpstream(fetchImpl, baseUrl, url, init, maxRedirects = 3) {
+  let current = url;
+  for (let hops = 0; ; hops += 1) {
+    const response = await fetchImpl(current, { ...init, redirect: 'manual' });
+    if (response.status < 300 || response.status > 399) return response;
+    const next = hops < maxRedirects
+      ? upstreamRedirectTarget(baseUrl, current, response.headers.get('location'))
+      : null;
+    try { await response.arrayBuffer(); } catch { /* body not needed */ }
+    if (!next) {
+      const err = new Error('The API answered with a redirect this server does not follow, so the request was not repeated.');
+      err.status = response.status;
+      throw err;
+    }
+    current = next;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinpaprika/mcp",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "A Model Context Protocol server for CoinPaprika cryptocurrency market data: prices, tickers, exchanges, and more",
   "main": "dist/index.js",
   "type": "module",
@@ -17,7 +17,7 @@
     "build": "mkdir -p dist && cp -r src/* dist/ && chmod +x dist/bin.js",
     "prepublishOnly": "npm run build",
     "start": "node src/index.js",
-    "test": "node test/smoke.js"
+    "test": "node test/path_safety.js && node test/smoke.js"
   },
   "keywords": [
     "mcp",