@chrischall/tripadvisor-mcp 0.0.0

package/dist/client.js

@@ -0,0 +1,149 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadDotenvSafely, readEnvVar, formatApiError, McpToolError } from '@chrischall/mcp-utils';
+// Load .env for local dev; silently skip if dotenv is unavailable (e.g. the
+// .mcpb bundle). loadDotenvSafely never lets .env override a host-provided value.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+await loadDotenvSafely({ path: join(__dirname, '..', '.env'), override: false });
+const BASE_URL = 'https://api.content.tripadvisor.com/api/v1';
+const SERVICE = 'TripAdvisor Content API';
+const REQUEST_TIMEOUT_MS = 30_000;
+// The Content API free tier is 5,000 calls/month, so identical GETs in quick
+// succession are wasteful. Search results get a 5-minute TTL by default;
+// override with TRIPADVISOR_CACHE_TTL (seconds; 0 = off).
+const DEFAULT_CACHE_TTL_MS = 300_000;
+// Location details/photos/reviews change slowly — 1 hour by default.
+// Override with TRIPADVISOR_STATIC_CACHE_TTL (seconds; 0 = off).
+const DEFAULT_STATIC_CACHE_TTL_MS = 3_600_000;
+// Bound the cache so a long-lived server doesn't grow unbounded across many
+// distinct paths; oldest entries are evicted first.
+const CACHE_MAX_ENTRIES = 256;
+// Cap a server-supplied Retry-After so one bad header can't stall a tool call.
+const MAX_RETRY_AFTER_MS = 10_000;
+/** Resolve a cache TTL (ms) from an env var holding seconds. A blank or
+ * non-numeric value falls back to `defaultMs`; a valid `0` disables caching. */
+function readCacheTtlMs(envVar, defaultMs) {
+    const raw = readEnvVar(envVar);
+    if (raw === undefined)
+        return defaultMs;
+    const secs = Number(raw);
+    return Number.isFinite(secs) && secs >= 0 ? secs * 1000 : defaultMs;
+}
+export class TripAdvisorClient {
+    apiKey;
+    configError;
+    referer;
+    fetchImpl;
+    sleep;
+    cacheTtlMs;
+    staticCacheTtlMs;
+    now;
+    cache = new Map();
+    /**
+     * Defer the config error so the server still boots (and answers the host's
+     * install-time tools/list probe) when TRIPADVISOR_API_KEY isn't set yet. The
+     * error is re-raised at request time via requireKey().
+     */
+    constructor(opts = {}) {
+        this.now = opts.now ?? Date.now;
+        this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        this.cacheTtlMs = opts.cacheTtlMs ?? readCacheTtlMs('TRIPADVISOR_CACHE_TTL', DEFAULT_CACHE_TTL_MS);
+        this.staticCacheTtlMs =
+            opts.staticCacheTtlMs ?? readCacheTtlMs('TRIPADVISOR_STATIC_CACHE_TTL', DEFAULT_STATIC_CACHE_TTL_MS);
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+        this.referer = readEnvVar('TRIPADVISOR_REFERER');
+        const key = readEnvVar('TRIPADVISOR_API_KEY');
+        if (!key) {
+            this.apiKey = null;
+            this.configError = new McpToolError('TRIPADVISOR_API_KEY environment variable is required', {
+                hint: 'Create a Content API key at https://www.tripadvisor.com/developers and set TRIPADVISOR_API_KEY in your MCP host env or .env (free tier: 5,000 calls/month).',
+            });
+        }
+        else {
+            this.apiKey = key;
+            this.configError = null;
+        }
+    }
+    requireKey() {
+        if (this.configError)
+            throw this.configError;
+        return this.apiKey;
+    }
+    /**
+     * GET a JSON resource. `path` must already include any query string but NOT
+     * the API key — the key is appended here at fetch time so it never appears in
+     * cache keys or error messages. Responses are cached by path; `cache:
+     * 'static'` selects the longer details/photos/reviews TTL
+     * (TRIPADVISOR_STATIC_CACHE_TTL), the default 'dynamic' tier
+     * (TRIPADVISOR_CACHE_TTL) is for searches.
+     */
+    async get(path, opts = {}) {
+        const ttl = opts.cache === 'static' ? this.staticCacheTtlMs : this.cacheTtlMs;
+        if (ttl > 0) {
+            const hit = this.cache.get(path);
+            if (hit && hit.expiresAt > this.now())
+                return hit.value;
+        }
+        const value = await this.request(path);
+        if (ttl > 0) {
+            if (this.cache.size >= CACHE_MAX_ENTRIES) {
+                // Evict expired entries first; if still full, drop the oldest (Map
+                // preserves insertion order, so the first key is the oldest).
+                const t = this.now();
+                for (const [k, v] of this.cache)
+                    if (v.expiresAt <= t)
+                        this.cache.delete(k);
+                while (this.cache.size >= CACHE_MAX_ENTRIES) {
+                    const oldest = this.cache.keys().next().value;
+                    if (oldest === undefined)
+                        break;
+                    this.cache.delete(oldest);
+                }
+            }
+            this.cache.set(path, { expiresAt: this.now() + ttl, value });
+        }
+        return value;
+    }
+    async request(path, isRetry = false) {
+        const key = this.requireKey();
+        const sep = path.includes('?') ? '&' : '?';
+        const url = `${BASE_URL}${path}${sep}key=${encodeURIComponent(key)}`;
+        const headers = { Accept: 'application/json' };
+        // A domain-restricted key requires a matching Referer on every request.
+        if (this.referer)
+            headers.Referer = this.referer;
+        const res = await this.fetchImpl(url, { headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        if (res.ok)
+            return (await res.json());
+        const text = await res.text();
+        if (res.status === 429 && !isRetry) {
+            const retryAfter = Number(res.headers.get('retry-after'));
+            const delayMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1000, MAX_RETRY_AFTER_MS) : 1_000;
+            await this.sleep(delayMs);
+            return this.request(path, true);
+        }
+        // `path` deliberately excludes the key, so these messages can't leak it.
+        if (res.status === 401) {
+            throw new McpToolError(`${SERVICE} returned 401 Unauthorized — TRIPADVISOR_API_KEY is missing or invalid.`, {
+                hint: 'Check the key in your MCP host env or .env; create one at https://www.tripadvisor.com/developers',
+            });
+        }
+        if (res.status === 403) {
+            throw new McpToolError(`${SERVICE} returned 403 Forbidden — the key is valid but blocked, usually by its domain/IP restriction (set at key creation) or an unapproved application.`, {
+                hint: 'If the key is domain-restricted, set TRIPADVISOR_REFERER to a matching https://domain; if IP-restricted, call from a listed address.',
+            });
+        }
+        if (res.status === 429) {
+            throw new McpToolError(`${SERVICE} rate limit or monthly quota exceeded (429).`, {
+                hint: 'The free tier is 5,000 calls/month — check usage at https://www.tripadvisor.com/developers. Cached reads (TRIPADVISOR_CACHE_TTL) stretch the quota.',
+            });
+        }
+        throw new McpToolError(formatApiError(res.status, 'GET', path, text, { service: SERVICE }));
+    }
+}
+/**
+ * Module-level singleton shared by every tool module. Constructed here (not in
+ * index.ts) so the deferred-config-error pattern holds: the server boots and
+ * lists tools even without a key — the error surfaces on the first tool call.
+ */
+export const client = new TripAdvisorClient();

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { runMcp } from '@chrischall/mcp-utils';
+import { VERSION } from './version.js';
+import { registerSearchTools } from './tools/search.js';
+import { registerLocationTools } from './tools/location.js';
+import { registerWebTools } from './tools/web.js';
+// The TripAdvisorClient is a module-level singleton (imported by each tool
+// module) that defers its config error to the first request — so the server
+// boots and answers the host's install-time tools/list probe even without
+// TRIPADVISOR_API_KEY.
+await runMcp({
+    name: 'tripadvisor-mcp',
+    version: VERSION,
+    banner: '[tripadvisor-mcp] This project was developed and is maintained by AI (Claude). Use at your own discretion.',
+    tools: [registerSearchTools, registerLocationTools, registerWebTools],
+});

package/dist/tools/location.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { textResult } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { LocationId, qs } from './shared.js';
+/** Photo source filter: comma-separated list of the three allowed origins. */
+const PhotoSource = z
+    .string()
+    .regex(/^(Expert|Management|Traveler)(,(Expert|Management|Traveler))*$/, 'must be a comma-separated list of: Expert, Management, Traveler');
+export function registerLocationTools(server) {
+    server.registerTool('ta_get_location_details', {
+        description: 'Get full details for a TripAdvisor location: name, address, coordinates, rating, ranking, subratings, awards, review count, amenities, hours, and listing URLs.',
+        annotations: { readOnlyHint: true, openWorldHint: true },
+        inputSchema: {
+            locationId: LocationId,
+            language: z.string().optional().describe('Result language code (default: en)'),
+            currency: z.string().optional().describe('ISO 4217 currency code for prices (default: USD)'),
+        },
+    }, async ({ locationId, language, currency }) => {
+        const data = await client.get(`/location/${locationId}/details${qs({ language, currency })}`, {
+            cache: 'static',
+        });
+        return textResult(data);
+    });
+    server.registerTool('ta_get_location_photos', {
+        description: 'Get photos for a TripAdvisor location (multi-size image URLs, captions, sources).',
+        annotations: { readOnlyHint: true, openWorldHint: true },
+        inputSchema: {
+            locationId: LocationId,
+            language: z.string().optional().describe('Caption language code (default: en)'),
+            limit: z.number().int().positive().optional().describe('Number of photos to return'),
+            offset: z.number().int().min(0).optional().describe('Index of the first photo'),
+            source: PhotoSource.optional().describe('Comma-separated photo sources to allow: Expert, Management, Traveler (default: all)'),
+        },
+    }, async ({ locationId, language, limit, offset, source }) => {
+        const data = await client.get(`/location/${locationId}/photos${qs({ language, limit, offset, source })}`, {
+            cache: 'static',
+        });
+        return textResult(data);
+    });
+    server.registerTool('ta_get_location_reviews', {
+        description: 'Get the most recent reviews for a TripAdvisor location (up to 5 per call; page with offset).',
+        annotations: { readOnlyHint: true, openWorldHint: true },
+        inputSchema: {
+            locationId: LocationId,
+            language: z.string().optional().describe('Review language code (default: en)'),
+            limit: z.number().int().positive().optional().describe('Number of reviews to return'),
+            offset: z.number().int().min(0).optional().describe('Index of the first review'),
+        },
+    }, async ({ locationId, language, limit, offset }) => {
+        const data = await client.get(`/location/${locationId}/reviews${qs({ language, limit, offset })}`, {
+            cache: 'static',
+        });
+        return textResult(data);
+    });
+}

package/dist/tools/search.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { textResult } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { LatLong, searchFilterParams, qs } from './shared.js';
+export function registerSearchTools(server) {
+    server.registerTool('ta_search_locations', {
+        description: 'Search TripAdvisor locations (hotels, restaurants, attractions, geos) by name. Returns up to 10 matches with location_id for the detail tools.',
+        annotations: { readOnlyHint: true, openWorldHint: true },
+        inputSchema: {
+            searchQuery: z.string().min(1).describe('Text to search location names for'),
+            latLong: LatLong.optional().describe('Center point to scope the search, e.g. "42.3455,-71.10767"'),
+            ...searchFilterParams,
+        },
+    }, async ({ searchQuery, latLong, category, phone, address, radius, radiusUnit, language }) => {
+        const data = await client.get(`/location/search${qs({ searchQuery, category, phone, address, latLong, radius, radiusUnit, language })}`, { cache: 'dynamic' });
+        return textResult(data);
+    });
+    server.registerTool('ta_search_nearby', {
+        description: 'Find TripAdvisor locations near a latitude/longitude. Returns up to 10 locations with location_id for the detail tools.',
+        annotations: { readOnlyHint: true, openWorldHint: true },
+        inputSchema: {
+            latLong: LatLong.describe('Center point, e.g. "42.3455,-71.10767"'),
+            ...searchFilterParams,
+        },
+    }, async ({ latLong, category, phone, address, radius, radiusUnit, language }) => {
+        const data = await client.get(`/location/nearby_search${qs({ latLong, category, phone, address, radius, radiusUnit, language })}`, { cache: 'dynamic' });
+        return textResult(data);
+    });
+}

package/dist/tools/shared.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { buildQueryString } from '@chrischall/mcp-utils';
+/** TripAdvisor location id — a positive integer (interpolated into the path). */
+export const LocationId = z.number().int().positive().describe('TripAdvisor location ID (from a search tool)');
+/** `"lat,long"` pair, e.g. `"42.3455,-71.10767"`. */
+export const LatLong = z
+    .string()
+    .regex(/^-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?$/, 'must be a "lat,long" pair like "42.3455,-71.10767"');
+/** Search category filter — the four values the Content API accepts. */
+export const Category = z.enum(['hotels', 'attractions', 'restaurants', 'geos']);
+/** Filters shared by the two search endpoints. */
+export const searchFilterParams = {
+    category: Category.optional().describe('Restrict results to one property type'),
+    phone: z.string().optional().describe('Phone number filter (spaces/dashes ok, no leading "+")'),
+    address: z.string().optional().describe('Address filter'),
+    radius: z.number().positive().optional().describe('Search radius around latLong (must be > 0)'),
+    radiusUnit: z.enum(['km', 'mi', 'm']).optional().describe('Unit for radius'),
+    language: z.string().optional().describe('Result language code (default: en)'),
+};
+/**
+ * Build a `?a=b&c=d` query string, dropping undefined values. Thin wrapper over
+ * the shared helper so every tool serializes params identically.
+ */
+export function qs(params) {
+    return buildQueryString(params);
+}

package/dist/tools/web.js

@@ -0,0 +1,28 @@
+import { registerBridgeHealthcheckTool } from '@chrischall/mcp-utils/fetchproxy';
+import { webClient } from '../web/client.js';
+/**
+ * A small, real page GET the probe round-trips — the homepage exercises the
+ * exact bridge + bot-wall guards every web tool uses.
+ */
+export const HEALTHCHECK_PROBE_PATH = '/';
+/**
+ * Register `ta_web_healthcheck` — round-trips the probe path through the
+ * fetchproxy bridge and reports role/port/timing plus an actionable hint
+ * ladder. The transport is reached lazily through `webClient.bridge()` so
+ * registration never constructs it at server startup.
+ */
+export function registerWebTools(server) {
+    registerBridgeHealthcheckTool({
+        server,
+        prefix: 'ta_web',
+        probePath: HEALTHCHECK_PROBE_PATH,
+        hostLabel: 'www.tripadvisor.com',
+        transport: {
+            // runProbe must go through the STARTED transport (start() loads the
+            // identity and must precede any verb), hence the async delegate.
+            runProbe: async (fetchFn, probePath) => (await webClient.bridgeReady()).runProbe(fetchFn, probePath),
+            status: () => webClient.bridge().status(),
+        },
+        probeFn: (path) => webClient.getHtml(path),
+    });
+}

package/dist/version.js

@@ -0,0 +1,2 @@
+/** Single source of the server version. release-please bumps the literal below. */
+export const VERSION = '0.0.0'; // x-release-please-version

package/dist/web/client.js

@@ -0,0 +1,114 @@
+// ────────────────────────────────────────────────────────────────────────────
+// TripAdvisor web client — every tripadvisor.com request rides the bridge
+// ────────────────────────────────────────────────────────────────────────────
+//
+// The consumer site is DataDome-fronted, so web-tier requests run as
+// same-origin fetches inside the user's open tripadvisor.com tab via the
+// fetchproxy bridge (src/web/transport.ts). The browser carries its own
+// cookies; nothing is captured or persisted here. This client is deliberately
+// generic ({method, path} → {status, body}) — endpoint knowledge lives in the
+// tools, pinned by docs/TRIPADVISOR-WEB-API.md captures.
+import { McpToolError } from '@chrischall/mcp-utils';
+import { bridgeErrorInfo, classifyBotWall } from '@chrischall/mcp-utils/fetchproxy';
+import { debugLogEnabled } from './config.js';
+import { createTripAdvisorTransport } from './transport.js';
+export class TripAdvisorWebClient {
+    injected;
+    transport;
+    startPromise;
+    constructor(injected = {}) {
+        this.injected = injected;
+    }
+    /**
+     * The bridge transport, created lazily (construction is cheap — the port
+     * only binds on the first verb call). Public so the healthcheck tool can
+     * probe/report bridge state without re-creating it.
+     */
+    bridge() {
+        if (!this.transport) {
+            this.transport = this.injected.transport ?? createTripAdvisorTransport();
+        }
+        return this.transport;
+    }
+    /**
+     * The bridge transport, started. Runs single-flight (concurrent callers
+     * share one start) and clears on rejection so a transient failure is retried
+     * on the next request instead of sticking forever.
+     */
+    async bridgeReady() {
+        const transport = this.bridge();
+        if (!this.startPromise) {
+            this.startPromise = transport.start().catch((e) => {
+                this.startPromise = undefined;
+                throw e;
+            });
+        }
+        await this.startPromise;
+        return transport;
+    }
+    /** Round-trip one request through the signed-in tab; bridge failures become actionable errors. */
+    async fetchRaw(method, path, opts = {}) {
+        if (debugLogEnabled())
+            console.error(`[tripadvisor-debug] → ${method} ${path}`);
+        let result;
+        try {
+            const transport = await this.bridgeReady();
+            result = await transport.fetch({
+                method,
+                path,
+                headers: opts.headers ?? {},
+                ...(opts.body !== undefined ? { body: opts.body } : {}),
+            });
+        }
+        catch (e) {
+            const info = bridgeErrorInfo(e);
+            throw new McpToolError(`TripAdvisor bridge: ${info.message}`, {
+                ...(info.hint ? { hint: info.hint } : {}),
+            });
+        }
+        if (debugLogEnabled())
+            console.error(`[tripadvisor-debug] ← ${result.status}`);
+        return result;
+    }
+    /** GET an HTML page. Throws on non-2xx or a bot-wall interstitial. */
+    async getHtml(path) {
+        const { status, body } = await this.fetchRaw('GET', path);
+        this.assertNotWalled(status, body, path);
+        if (status < 200 || status >= 300) {
+            throw new McpToolError(`tripadvisor.com answered ${status} for ${path}`, {
+                hint: 'If this persists, run ta_web_healthcheck and make sure a tripadvisor.com tab is open.',
+            });
+        }
+        return body;
+    }
+    /** GET a JSON endpoint. A non-JSON 2xx is almost always a bot-challenge interstitial. */
+    async getJson(path, headers = {}) {
+        const { status, body } = await this.fetchRaw('GET', path, {
+            headers: { Accept: 'application/json', ...headers },
+        });
+        this.assertNotWalled(status, body, path);
+        if (status < 200 || status >= 300) {
+            throw new McpToolError(`tripadvisor.com answered ${status} for ${path}`, {
+                hint: 'If this persists, run ta_web_healthcheck and make sure a tripadvisor.com tab is open.',
+            });
+        }
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            throw new McpToolError(`tripadvisor.com answered 2xx but non-JSON for ${path} — likely a bot-challenge interstitial.`, {
+                hint: 'Open (or refresh) a www.tripadvisor.com tab in the paired browser so the challenge clears, then retry.',
+            });
+        }
+    }
+    assertNotWalled(status, body, path) {
+        const wall = classifyBotWall(body, status);
+        if (wall.blocked) {
+            throw new McpToolError(`tripadvisor.com bot wall (${wall.vendor}) blocked ${path}.`, {
+                hint: 'Open a www.tripadvisor.com tab in the paired browser, complete any challenge, then retry.',
+            });
+        }
+    }
+}
+/** Module-level singleton shared by the web tool modules (lazy — nothing binds at import). */
+export const webClient = new TripAdvisorWebClient();

package/dist/web/config.js

@@ -0,0 +1,22 @@
+import { parseBoolEnv, readEnvVar, readPortEnv } from '@chrischall/mcp-utils';
+// The whole fetchproxy fleet shares ONE concentrator port — the Transporter
+// extension dials it, and servers host/peer-elect on it. Never default to a
+// "unique" port; override only for test isolation.
+const DEFAULT_WS_PORT = 37_149;
+/** Bridge concentrator port. Override with TRIPADVISOR_WS_PORT (tests only). */
+export function getWsPort() {
+    return readPortEnv('TRIPADVISOR_WS_PORT', DEFAULT_WS_PORT);
+}
+// Comfortably above tripadvisor.com's typical latency but low enough that a
+// stuck upstream (or a DataDome challenge that never resolves) fails fast.
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** Per-request bridge timeout. Override with TRIPADVISOR_REQUEST_TIMEOUT_MS. */
+export function getRequestTimeoutMs() {
+    const raw = readEnvVar('TRIPADVISOR_REQUEST_TIMEOUT_MS');
+    const ms = Number(raw);
+    return Number.isFinite(ms) && ms > 0 ? ms : DEFAULT_REQUEST_TIMEOUT_MS;
+}
+/** Per-request bridge debug logging (stderr). Set TRIPADVISOR_DEBUG_LOG=1. */
+export function debugLogEnabled() {
+    return parseBoolEnv('TRIPADVISOR_DEBUG_LOG');
+}

package/dist/web/transport.js

@@ -0,0 +1,46 @@
+// ────────────────────────────────────────────────────────────────────────────
+// Fetchproxy bridge transport — the hot path for every tripadvisor.com request
+// ────────────────────────────────────────────────────────────────────────────
+//
+// tripadvisor.com fronts its consumer site with DataDome, which fingerprints
+// the HTTP client itself (TLS/JA3) — Node-originated requests are rejected
+// regardless of cookie freshness. So web-tier requests run through the
+// fetchproxy bridge: each one is a same-origin fetch executed in the user's
+// open tripadvisor.com tab, and the bot wall never sees Node. The official
+// Content API tools (src/client.ts) are unaffected — they never touch the
+// bridge.
+//
+// This is the fleet's fetchproxy archetype (alltrails/redfin/zillow): a thin
+// factory over @chrischall/mcp-utils' createFetchproxyTransport, which owns
+// the FetchproxyServer construction, the start/close/status lifecycle, and
+// the fetch/requestJson/runProbe verb adapters.
+import { createFetchproxyTransport, } from '@chrischall/mcp-utils/fetchproxy';
+import { getRequestTimeoutMs, getWsPort } from './config.js';
+import { VERSION } from '../version.js';
+/**
+ * Build the TripAdvisor bridge transport. Construction is cheap — the port
+ * only binds (and the extension only pairs) on the first verb call, so callers
+ * can create this eagerly without touching the bridge.
+ *
+ * @param createServer Test seam forwarded to `createFetchproxyTransport`: a
+ *   factory that builds the underlying `FetchproxyServer`. Tests pass a
+ *   capturing mock; production omits it.
+ */
+export function createTripAdvisorTransport(createServer) {
+    return createFetchproxyTransport({
+        port: getWsPort(),
+        serverName: 'tripadvisor-mcp',
+        version: VERSION,
+        // 'tripadvisor.com' matches www.tripadvisor.com (the extension treats each
+        // domain as "exact host or any subdomain of it").
+        domains: ['tripadvisor.com'],
+        defaultSubdomain: 'www',
+        capabilities: ['fetch'],
+        // Canonical fleet startup banner on start() — stderr only (stdout is the
+        // JSON-RPC channel).
+        logListening: true,
+        debugEnvVar: 'TRIPADVISOR_DEBUG_LOG',
+        fetchTimeoutMs: getRequestTimeoutMs(),
+        ...(createServer ? { createServer } : {}),
+    });
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@chrischall/tripadvisor-mcp",
+  "version": "0.0.0",
+  "mcpName": "io.github.chrischall/tripadvisor-mcp",
+  "description": "TripAdvisor Content API MCP server for Claude \u2014 search locations, details, photos, and reviews. Developed and maintained by AI (Claude Code).",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chrischall/tripadvisor-mcp.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "tripadvisor",
+    "travel",
+    "hotels",
+    "restaurants",
+    "attractions",
+    "reviews"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "tripadvisor-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    "SKILL.md",
+    ".mcp.json",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --external:dotenv --outfile=dist/bundle.js",
+    "dev": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@chrischall/mcp-utils": "^0.10.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^17.4.0",
+    "zod": "^4.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "^4.1.2",
+    "esbuild": "^0.28.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "allowScripts": {
+    "esbuild@0.28.1": true
+  }
+}

package/server.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.chrischall/tripadvisor-mcp",
+  "description": "TripAdvisor location search, details, photos, and reviews via the official Content API",
+  "repository": {
+    "url": "https://github.com/chrischall/tripadvisor-mcp",
+    "source": "github"
+  },
+  "version": "0.0.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@chrischall/tripadvisor-mcp",
+      "version": "0.0.0",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "TRIPADVISOR_API_KEY",
+          "description": "Your TripAdvisor Content API key (tripadvisor.com/developers)",
+          "isRequired": true,
+          "format": "string",
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}