snowsure-mcp-server 3.0.1

package/README.md

@@ -0,0 +1,165 @@
+# SnowSure MCP Server — ski resort snow for Cursor, Claude & AI agents
+
+**`npx snowsure-mcp-server`** — [Model Context Protocol](https://modelcontextprotocol.io/) server for **real-time powder rankings**, **14-day multi-model snow forecasts**, and **500+ ski resorts** via [SnowSure](https://www.snowsure.ai). Use it when building agents that answer: *where is the best snow*, *fresh powder in Japan/the Alps*, *compare two resorts*, or *trip planning by conditions*.
+
+- Docs: [snowsure.ai/developers](https://www.snowsure.ai/developers) · [llms.txt](https://www.snowsure.ai/llms.txt) · [OpenAPI](https://www.snowsure.ai/openapi.json)
+
+## Features
+
+- **11 AI Tools** for querying snow conditions, forecasts, and resort information
+- **4 Resources** for direct data access
+- **500+ ski resorts** worldwide
+- **7 weather models** for forecast comparison
+- **Frequent updates** (weather pipeline ~15 min; see [methodology](https://www.snowsure.ai/methodology))
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `get_snow_report` | Global snow rankings by score, forecast, or recent snowfall |
+| `get_resort` | Comprehensive resort details including AI analysis |
+| `search_resorts` | Find resorts by name, country, or region |
+| `find_best_powder` | Resorts with freshest powder (24h snowfall) |
+| `compare_forecasts` | Multi-model forecast comparison with confidence |
+| `get_weather_forecast` | Day-by-day weather for up to 14 days |
+| `find_resorts_by_criteria` | Advanced filtering (depth, elevation, runs, score) |
+| `get_snow_history` | Historical data and season comparisons |
+| `plan_ski_trip` | AI-powered trip recommendations |
+| `get_webcam_status` | Live webcam links for a resort |
+| `get_regional_summary` | Regional statistics and top resorts |
+
+## Available Resources
+
+| URI | Description |
+|-----|-------------|
+| `snowsure://snow-report` | Current global snow report (top 50) |
+| `snowsure://resorts` | All 500+ resorts with conditions |
+| `snowsure://regions` | Region/country breakdown |
+| `snowsure://api-docs` | API documentation |
+
+## Installation
+
+### For Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "snowsure": {
+      "command": "npx",
+      "args": ["-y", "snowsure-mcp-server"]
+    }
+  }
+}
+```
+
+### For Cursor
+
+Add to your MCP settings:
+
+```json
+{
+  "snowsure": {
+    "command": "npx",
+    "args": ["-y", "snowsure-mcp-server"]
+  }
+}
+```
+
+### Manual Installation
+
+```bash
+# Clone and build
+git clone https://github.com/mikeslone/snowsure-web.git
+cd snowsure-web/mcp-server
+npm install
+npm run build
+
+# Run
+node dist/index.js
+```
+
+## Example Queries
+
+Once connected, you can ask your AI assistant:
+
+- "What are the best ski conditions right now?"
+- "Tell me about Niseko's snow conditions"
+- "Find me powder in Japan"
+- "Compare forecasts for Matterhorn"
+- "Plan a ski trip to the Alps in February"
+- "Which resorts have the deepest snow base?"
+- "What's the weather forecast for Jackson Hole this week?"
+
+## Tool Usage Examples
+
+### Get Snow Report
+```
+Query: "Show me the top 5 resorts in Europe right now"
+Tool: get_snow_report
+Args: { "region": "europe", "limit": 5, "sort": "snowsure" }
+```
+
+### Find Best Powder
+```
+Query: "Where is it dumping in North America?"
+Tool: find_best_powder
+Args: { "region": "north-america", "minSnowfall": 15 }
+```
+
+### Compare Forecasts
+```
+Query: "How reliable is the Whistler forecast?"
+Tool: compare_forecasts
+Args: { "slug": "whistler-blackcomb" }
+```
+
+### Plan Trip
+```
+Query: "Recommend a ski trip for an advanced skier in Japan"
+Tool: plan_ski_trip
+Args: { "region": "asia", "level": "advanced" }
+```
+
+## API Reference
+
+The MCP server connects to the SnowSure API at `https://lux.ski/api/v1`.
+
+### Endpoints Used
+- `GET /resorts` - List all resorts
+- `GET /resorts/{slug}` - Get resort details
+- `GET /snow-report` - Get ranked snow report
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development mode
+npm run dev
+
+# Build for production
+npm run build
+
+# Watch mode
+npm run watch
+```
+
+## Data Sources
+
+- **Weather Models:** ECMWF, GFS, GEM, JMA, ICON, Météo-France, Met Norway
+- **Conditions:** Resort weather pipeline ~15 min cadence (production)
+- **Historical:** 30 years of snowfall records
+- **SnowSure Score:** AI-powered rating combining depth, recent snow, forecast, and historical reliability
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Support
+
+- Website: [snowsure.ai](https://www.snowsure.ai)
+- API Docs: [snowsure.ai/developers](https://www.snowsure.ai/developers)
+- Email: support@snowsure.ai

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * SnowSure MCP Server
+ *
+ * Provides AI agents with comprehensive access to real-time snow conditions,
+ * forecasts, historical data, and resort information from SnowSure.ai
+ *
+ * Tools:
+ * - get_snow_report: Global snow rankings
+ * - get_resort: Detailed resort info
+ * - search_resorts: Find resorts by name/country
+ * - find_best_powder: Fresh snow rankings
+ * - compare_forecasts: Multi-model comparison
+ * - get_weather_forecast: Daily forecast data
+ * - find_resorts_by_criteria: Advanced filtering
+ * - get_snow_history: Historical snowfall data
+ * - plan_ski_trip: Trip recommendations
+ * - get_webcam_status: Live webcam info
+ *
+ * Resources:
+ * - snowsure://snow-report: Live snow report
+ * - snowsure://resorts: All resorts list
+ * - snowsure://regions: Available regions
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,891 @@
+#!/usr/bin/env node
+/**
+ * SnowSure MCP Server
+ *
+ * Provides AI agents with comprehensive access to real-time snow conditions,
+ * forecasts, historical data, and resort information from SnowSure.ai
+ *
+ * Tools:
+ * - get_snow_report: Global snow rankings
+ * - get_resort: Detailed resort info
+ * - search_resorts: Find resorts by name/country
+ * - find_best_powder: Fresh snow rankings
+ * - compare_forecasts: Multi-model comparison
+ * - get_weather_forecast: Daily forecast data
+ * - find_resorts_by_criteria: Advanced filtering
+ * - get_snow_history: Historical snowfall data
+ * - plan_ski_trip: Trip recommendations
+ * - get_webcam_status: Live webcam info
+ *
+ * Resources:
+ * - snowsure://snow-report: Live snow report
+ * - snowsure://resorts: All resorts list
+ * - snowsure://regions: Available regions
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+const API_BASE = 'https://www.snowsure.ai/api/v1';
+// Helper to fetch from API with error handling
+async function fetchAPI(endpoint) {
+    try {
+        const res = await fetch(`${API_BASE}${endpoint}`, {
+            headers: {
+                'User-Agent': 'SnowSure-MCP/3.0.1',
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        }
+        return res.json();
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch ${endpoint}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+// Format date helper
+function formatDate(dateStr) {
+    if (!dateStr)
+        return 'Unknown';
+    const date = new Date(dateStr);
+    return date.toLocaleDateString('en-US', {
+        weekday: 'short',
+        month: 'short',
+        day: 'numeric'
+    });
+}
+// Create the MCP server
+const server = new Server({
+    name: 'snowsure-mcp',
+    version: '3.0.1',
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// List available tools - comprehensive set for AI agents
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        // === CORE TOOLS ===
+        {
+            name: 'get_snow_report',
+            description: 'Get the global snow report with top-ranked resorts by snow conditions. Returns resorts sorted by SnowSure score, forecast, or recent snowfall. Use this for "where has the best snow?" or "top ski resorts right now" queries.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sort: {
+                        type: 'string',
+                        enum: ['snowsure', 'forecast', 'recent', 'depth'],
+                        description: 'Sort order: snowsure (AI rating), forecast (14-day snow), recent (24h snowfall), depth (current base)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of resorts to return (default: 10, max: 50)',
+                    },
+                    region: {
+                        type: 'string',
+                        enum: ['europe', 'north-america', 'asia', 'oceania', 'south-america'],
+                        description: 'Filter by region',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_resort',
+            description: 'Get comprehensive information about a specific ski resort including current conditions, multi-model forecasts, historical data, webcams, and AI analysis. Use for "tell me about [resort]" or "[resort] conditions" queries.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: {
+                        type: 'string',
+                        description: 'Resort slug identifier (e.g., "niseko-hanazono-resort", "matterhorn-ski-paradise", "jackson-hole-mountain-resort")',
+                    },
+                },
+                required: ['slug'],
+            },
+        },
+        {
+            name: 'search_resorts',
+            description: 'Search for ski resorts by name, country, or region. Returns matching resorts with basic conditions. Use for "find resorts in [location]" or "search [name]" queries.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query - can be resort name, country, or partial match',
+                    },
+                    country: {
+                        type: 'string',
+                        description: 'Filter by exact country name (e.g., "Japan", "Switzerland", "United States")',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum results to return (default: 20)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'find_best_powder',
+            description: 'Find resorts with the freshest powder snow right now. Returns resorts sorted by 24-hour snowfall. Use for "where is it snowing?" or "fresh powder" queries.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    minSnowfall: {
+                        type: 'number',
+                        description: 'Minimum 24h snowfall in cm to include (default: 5)',
+                    },
+                    region: {
+                        type: 'string',
+                        enum: ['europe', 'north-america', 'asia', 'oceania'],
+                        description: 'Filter by region',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of results (default: 10)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'compare_forecasts',
+            description: 'Compare 14-day snow forecasts across 7 weather models (ECMWF, GFS, GEM, JMA, ICON, Météo-France, Met Norway) for a resort. Shows model agreement and uncertainty. Use for forecast reliability queries.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: {
+                        type: 'string',
+                        description: 'Resort slug to compare forecasts for',
+                    },
+                },
+                required: ['slug'],
+            },
+        },
+        // === ADVANCED TOOLS ===
+        {
+            name: 'get_weather_forecast',
+            description: 'Get detailed day-by-day weather forecast for a resort including temperature, snowfall, wind, and conditions for each of the next 14 days.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: {
+                        type: 'string',
+                        description: 'Resort slug',
+                    },
+                    days: {
+                        type: 'number',
+                        description: 'Number of days to forecast (default: 7, max: 14)',
+                    },
+                },
+                required: ['slug'],
+            },
+        },
+        {
+            name: 'find_resorts_by_criteria',
+            description: 'Find resorts matching specific criteria like minimum snow depth, elevation range, number of runs, or SnowSure rating. Advanced filtering for trip planning.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    minScore: {
+                        type: 'number',
+                        description: 'Minimum SnowSure score (0-100)',
+                    },
+                    minDepth: {
+                        type: 'number',
+                        description: 'Minimum snow depth in cm',
+                    },
+                    minElevation: {
+                        type: 'number',
+                        description: 'Minimum summit elevation in meters',
+                    },
+                    minRuns: {
+                        type: 'number',
+                        description: 'Minimum number of ski runs',
+                    },
+                    country: {
+                        type: 'string',
+                        description: 'Filter by country',
+                    },
+                    region: {
+                        type: 'string',
+                        enum: ['europe', 'north-america', 'asia'],
+                        description: 'Filter by region',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results (default: 20)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_snow_history',
+            description: 'Get historical snowfall data for a resort including season totals, comparison to 5-year and 30-year averages, and best months to visit.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: {
+                        type: 'string',
+                        description: 'Resort slug',
+                    },
+                },
+                required: ['slug'],
+            },
+        },
+        {
+            name: 'plan_ski_trip',
+            description: 'Get AI-powered ski trip recommendations based on dates, preferences, and conditions. Suggests best resorts for a given time period.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    region: {
+                        type: 'string',
+                        enum: ['europe', 'north-america', 'asia', 'any'],
+                        description: 'Preferred region (default: any)',
+                    },
+                    dates: {
+                        type: 'string',
+                        description: 'Travel dates or month (e.g., "February", "next week", "Jan 15-22")',
+                    },
+                    level: {
+                        type: 'string',
+                        enum: ['beginner', 'intermediate', 'advanced', 'expert'],
+                        description: 'Skier ability level',
+                    },
+                    priorities: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            enum: ['powder', 'groomed', 'terrain-variety', 'short-lift-lines', 'apres-ski', 'family-friendly', 'budget'],
+                        },
+                        description: 'Trip priorities',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_webcam_status',
+            description: 'Get live webcam information and links for a resort to see current conditions visually.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    slug: {
+                        type: 'string',
+                        description: 'Resort slug',
+                    },
+                },
+                required: ['slug'],
+            },
+        },
+        {
+            name: 'get_regional_summary',
+            description: 'Get a summary of snow conditions across an entire region or country with statistics and top resorts.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    region: {
+                        type: 'string',
+                        enum: ['europe', 'north-america', 'asia', 'alps', 'rockies', 'japan'],
+                        description: 'Region to summarize',
+                    },
+                    country: {
+                        type: 'string',
+                        description: 'Specific country (alternative to region)',
+                    },
+                },
+            },
+        },
+    ],
+}));
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            // === CORE TOOLS ===
+            case 'get_snow_report': {
+                const params = new URLSearchParams();
+                if (args?.sort)
+                    params.set('sort', args.sort);
+                if (args?.limit)
+                    params.set('limit', String(args.limit));
+                if (args?.region)
+                    params.set('region', args.region);
+                const data = await fetchAPI(`/snow-report?${params}`);
+                const resorts = data.data?.resorts || data.data || [];
+                const summary = `# 🏔️ Global Snow Report\n\n` +
+                    `**Updated:** ${new Date().toLocaleString()}\n\n` +
+                    `## Top Resorts\n\n` +
+                    resorts.slice(0, args?.limit || 10).map((r, i) => `${i + 1}. **${r.name}** (${r.country})\n` +
+                        `   - SnowSure Score: ${r.snowSure?.score || 'N/A'}/100 (${r.snowSure?.rating || 'N/A'})\n` +
+                        `   - Snow Depth: ${r.conditions?.snowDepthCm || 'N/A'}cm\n` +
+                        `   - 24h Snowfall: ${r.conditions?.snowfall24hCm || 0}cm\n` +
+                        `   - 14-Day Forecast: ${Math.round(r.conditions?.forecast14dCm || 0)}cm\n`).join('\n');
+                return {
+                    content: [{ type: 'text', text: summary }],
+                };
+            }
+            case 'get_resort': {
+                const data = await fetchAPI(`/resorts/${args?.slug}`);
+                const resort = data.data;
+                if (!resort) {
+                    return {
+                        content: [{ type: 'text', text: `Resort "${args?.slug}" not found. Try searching for resorts first.` }],
+                    };
+                }
+                const summary = `# ${resort.name}\n\n` +
+                    `**Location:** ${resort.country}${resort.region ? ` (${resort.region})` : ''}\n` +
+                    `**Website:** ${resort.links?.website || 'N/A'}\n\n` +
+                    `## SnowSure™ Score: ${resort.snowSure?.score || 'N/A'}/100\n` +
+                    `**Rating:** ${resort.snowSure?.rating || 'N/A'}\n` +
+                    `**Trend:** ${resort.snowSure?.trend || 'stable'}\n\n` +
+                    `${resort.snowSure?.analysis || resort.snowSure?.tagline || ''}\n\n` +
+                    `### Score Breakdown\n` +
+                    `- Depth: ${resort.snowSure?.breakdown?.depth || 'N/A'}/25\n` +
+                    `- Recent Snow: ${resort.snowSure?.breakdown?.recent || 'N/A'}/25\n` +
+                    `- Forecast: ${resort.snowSure?.breakdown?.forecast || 'N/A'}/25\n` +
+                    `- Historic: ${resort.snowSure?.breakdown?.historic || 'N/A'}/25\n\n` +
+                    `## Current Conditions\n` +
+                    `- **Temperature:** ${resort.currentConditions?.temperature?.celsius || 'N/A'}°C\n` +
+                    `- **Conditions:** ${resort.currentConditions?.conditions || 'N/A'}\n` +
+                    `- **Wind:** ${resort.currentConditions?.wind?.speed || 'N/A'} km/h\n` +
+                    `- **Snow Depth:** ${resort.snow?.depth?.cm || 'N/A'}cm\n` +
+                    `- **Last 24h:** ${resort.snow?.last24h?.cm || 0}cm\n` +
+                    `- **Last 7 Days:** ${resort.snow?.last7d?.cm || 0}cm\n` +
+                    `- **Season Total:** ${resort.snow?.seasonTotal?.cm || 'N/A'}cm\n` +
+                    `- **Last Updated:** ${formatDate(resort.currentConditions?.lastUpdated)}\n\n` +
+                    `## 14-Day Forecast (Multi-Model)\n` +
+                    `- **SnowSure Average:** ${resort.forecast?.total14d?.average || 'N/A'}cm\n` +
+                    `- **ECMWF:** ${resort.forecast?.total14d?.ecmwf || 'N/A'}cm\n` +
+                    `- **GFS:** ${resort.forecast?.total14d?.gfs || 'N/A'}cm\n` +
+                    `- **GEM:** ${resort.forecast?.total14d?.gem || 'N/A'}cm\n` +
+                    `- **JMA:** ${resort.forecast?.total14d?.jma || 'N/A'}cm\n` +
+                    `- **ICON:** ${resort.forecast?.total14d?.icon || 'N/A'}cm\n\n` +
+                    `## Resort Info\n` +
+                    `- **Summit:** ${resort.elevation?.summit || 'N/A'}m\n` +
+                    `- **Base:** ${resort.elevation?.base || 'N/A'}m\n` +
+                    `- **Vertical Drop:** ${resort.elevation?.vertical || 'N/A'}m\n` +
+                    `- **Runs:** ${resort.stats?.runs || 'N/A'}\n` +
+                    `- **Lifts:** ${resort.stats?.lifts || 'N/A'}\n` +
+                    `- **Skiable Area:** ${resort.stats?.skiableAcres || 'N/A'} acres\n` +
+                    `- **Annual Snowfall:** ${resort.stats?.annualSnowfall || 'N/A'}\n\n` +
+                    `${resort.description ? `## About\n${resort.description}\n\n` : ''}` +
+                    `${resort.topApresSki ? `## Top Après-Ski\n${resort.topApresSki}\n\n` : ''}` +
+                    `---\n` +
+                    `*View more at: https://snowsure.ai/resorts/${resort.slug}*`;
+                return {
+                    content: [{ type: 'text', text: summary }],
+                };
+            }
+            case 'search_resorts': {
+                const data = await fetchAPI('/resorts?limit=200');
+                let results = data.data || [];
+                if (args?.query) {
+                    const query = args.query.toLowerCase();
+                    results = results.filter((r) => r.name?.toLowerCase().includes(query) ||
+                        r.country?.toLowerCase().includes(query) ||
+                        r.region?.toLowerCase().includes(query) ||
+                        r.slug?.toLowerCase().includes(query));
+                }
+                if (args?.country) {
+                    const country = args.country.toLowerCase();
+                    results = results.filter((r) => r.country?.toLowerCase() === country);
+                }
+                const limit = args?.limit || 20;
+                const formatted = results.slice(0, limit).map((r) => `- **${r.name}** (${r.country})\n` +
+                    `  Slug: \`${r.slug}\` | Score: ${r.snowSure?.score || 'N/A'} | Depth: ${r.conditions?.snowDepthCm || 'N/A'}cm`).join('\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Search Results\n\nFound **${results.length}** resorts${args?.query ? ` matching "${args.query}"` : ''}${args?.country ? ` in ${args.country}` : ''}:\n\n${formatted}\n\n*Use the slug value with get_resort for detailed info.*`,
+                        },
+                    ],
+                };
+            }
+            case 'find_best_powder': {
+                const data = await fetchAPI('/snow-report?sort=recent&limit=50');
+                let results = data.data?.resorts || data.data || [];
+                const minSnow = args?.minSnowfall || 0;
+                results = results.filter((r) => (r.conditions?.snowfall24hCm || 0) >= minSnow);
+                if (args?.region) {
+                    const regionMap = {
+                        'europe': ['Switzerland', 'France', 'Austria', 'Italy', 'Germany', 'Norway', 'Sweden'],
+                        'north-america': ['United States', 'Canada'],
+                        'asia': ['Japan'],
+                        'oceania': ['New Zealand', 'Australia'],
+                    };
+                    const countries = regionMap[args.region] || [];
+                    if (countries.length > 0) {
+                        results = results.filter((r) => countries.includes(r.country));
+                    }
+                }
+                const limit = args?.limit || 10;
+                const formatted = results.slice(0, limit).map((r, i) => `${i + 1}. 🏔️ **${r.name}** (${r.country})\n` +
+                    `   ❄️ **+${r.conditions?.snowfall24hCm || 0}cm** in last 24 hours\n` +
+                    `   📏 Total Depth: ${r.conditions?.snowDepthCm || 'N/A'}cm\n` +
+                    `   🎯 SnowSure Score: ${r.snowSure?.score || 'N/A'}/100`).join('\n\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# 🎿 Fresh Powder Report\n\n${formatted || 'No resorts with fresh powder found matching your criteria.'}\n\n*Data updated: ${new Date().toLocaleString()}*`,
+                        },
+                    ],
+                };
+            }
+            case 'compare_forecasts': {
+                const data = await fetchAPI(`/resorts/${args?.slug}`);
+                const resort = data.data;
+                if (!resort?.forecast?.total14d) {
+                    return {
+                        content: [{ type: 'text', text: 'Forecast data not available for this resort.' }],
+                    };
+                }
+                const f = resort.forecast.total14d;
+                const models = [
+                    { name: 'ECMWF', value: f.ecmwf, desc: 'European model (most accurate)' },
+                    { name: 'GFS', value: f.gfs, desc: 'US Global Forecast System' },
+                    { name: 'GEM', value: f.gem, desc: 'Canadian model' },
+                    { name: 'JMA', value: f.jma, desc: 'Japanese model (best for Asia)' },
+                    { name: 'ICON', value: f.icon, desc: 'German model' },
+                    { name: 'Météo-Fr', value: f.meteoFrance, desc: 'French model' },
+                    { name: 'Met Norway', value: f.metNorway, desc: 'Norwegian model' },
+                ].filter(m => m.value !== undefined && m.value !== null);
+                const avg = f.average || 0;
+                const max = Math.max(...models.map(m => m.value || 0), 1);
+                const min = Math.min(...models.map(m => m.value || 0));
+                const spread = max - min;
+                const chart = models.map(m => {
+                    const pct = max > 0 ? Math.round((m.value || 0) / max * 20) : 0;
+                    const bar = '█'.repeat(pct) + '░'.repeat(20 - pct);
+                    const diff = (m.value || 0) - avg;
+                    const diffStr = diff >= 0 ? `+${diff.toFixed(0)}` : diff.toFixed(0);
+                    return `${m.name.padEnd(10)} ${bar} ${(m.value || 0).toString().padStart(3)}cm (${diffStr})`;
+                }).join('\n');
+                const confidence = spread < 10 ? 'HIGH' : spread < 25 ? 'MEDIUM' : 'LOW';
+                const confidenceEmoji = confidence === 'HIGH' ? '🟢' : confidence === 'MEDIUM' ? '🟡' : '🔴';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# 14-Day Forecast Comparison\n## ${resort.name}\n\n` +
+                                `**SnowSure™ Average:** ${avg}cm\n` +
+                                `**Model Spread:** ${spread.toFixed(0)}cm (${min}-${max}cm)\n` +
+                                `**Confidence:** ${confidenceEmoji} ${confidence}\n\n` +
+                                `\`\`\`\n${chart}\n\`\`\`\n\n` +
+                                `### Model Notes\n` +
+                                `- **ECMWF** is typically most accurate globally\n` +
+                                `- **JMA** excels for Japan/Asia forecasts\n` +
+                                `- **GEM** is strongest for North America\n` +
+                                `- SnowSure uses weighted averages based on historical accuracy\n\n` +
+                                `*${confidence === 'HIGH' ? 'Models agree closely - forecast is reliable' : confidence === 'MEDIUM' ? 'Some model disagreement - check closer to date' : 'High uncertainty - conditions may change significantly'}*`,
+                        },
+                    ],
+                };
+            }
+            // === ADVANCED TOOLS ===
+            case 'get_weather_forecast': {
+                const data = await fetchAPI(`/resorts/${args?.slug}`);
+                const resort = data.data;
+                if (!resort?.forecast?.daily) {
+                    return {
+                        content: [{ type: 'text', text: 'Daily forecast not available for this resort.' }],
+                    };
+                }
+                const days = Math.min(args?.days || 7, 14);
+                const forecast = resort.forecast.daily.slice(0, days);
+                const formatted = forecast.map((day, i) => {
+                    const date = new Date();
+                    date.setDate(date.getDate() + i);
+                    const dayName = i === 0 ? 'Today' : i === 1 ? 'Tomorrow' : date.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' });
+                    return `### ${dayName}\n` +
+                        `- High: ${day.tempMax || day.temp || 'N/A'}°C | Low: ${day.tempMin || 'N/A'}°C\n` +
+                        `- Conditions: ${day.conditions || 'N/A'}\n` +
+                        `- Snowfall: ${day.snowfall || 0}cm\n` +
+                        `- Wind: ${day.windSpeed || 'N/A'} km/h`;
+                }).join('\n\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# ${days}-Day Forecast: ${resort.name}\n\n${formatted}`,
+                        },
+                    ],
+                };
+            }
+            case 'find_resorts_by_criteria': {
+                const data = await fetchAPI('/resorts?limit=200');
+                let results = data.data || [];
+                // Apply filters
+                if (args?.minScore != null) {
+                    const min = Number(args.minScore);
+                    results = results.filter((r) => (r.snowSure?.score || 0) >= min);
+                }
+                if (args?.minDepth != null) {
+                    const min = Number(args.minDepth);
+                    results = results.filter((r) => (r.conditions?.snowDepthCm || 0) >= min);
+                }
+                if (args?.minElevation != null) {
+                    const min = Number(args.minElevation);
+                    results = results.filter((r) => (r.elevation?.summit || 0) >= min);
+                }
+                if (args?.minRuns != null) {
+                    const min = Number(args.minRuns);
+                    results = results.filter((r) => (r.stats?.runs || 0) >= min);
+                }
+                if (args?.country) {
+                    results = results.filter((r) => r.country?.toLowerCase() === args.country.toLowerCase());
+                }
+                if (args?.region) {
+                    const regionMap = {
+                        'europe': ['Switzerland', 'France', 'Austria', 'Italy', 'Germany', 'Norway'],
+                        'north-america': ['United States', 'Canada'],
+                        'asia': ['Japan'],
+                    };
+                    const countries = regionMap[args.region] || [];
+                    if (countries.length > 0) {
+                        results = results.filter((r) => countries.includes(r.country));
+                    }
+                }
+                // Sort by score
+                results.sort((a, b) => (b.snowSure?.score || 0) - (a.snowSure?.score || 0));
+                const limit = args?.limit || 20;
+                const formatted = results.slice(0, limit).map((r, i) => `${i + 1}. **${r.name}** (${r.country})\n` +
+                    `   Score: ${r.snowSure?.score || 'N/A'} | Depth: ${r.conditions?.snowDepthCm || 'N/A'}cm | ` +
+                    `Summit: ${r.elevation?.summit || 'N/A'}m | Runs: ${r.stats?.runs || 'N/A'}`).join('\n');
+                const filterDesc = [
+                    args?.minScore && `Score ≥ ${args.minScore}`,
+                    args?.minDepth && `Depth ≥ ${args.minDepth}cm`,
+                    args?.minElevation && `Summit ≥ ${args.minElevation}m`,
+                    args?.minRuns && `Runs ≥ ${args.minRuns}`,
+                    args?.country && `Country: ${args.country}`,
+                    args?.region && `Region: ${args.region}`,
+                ].filter(Boolean).join(', ');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Resorts Matching Criteria\n\n**Filters:** ${filterDesc || 'None'}\n**Results:** ${results.length} resorts found\n\n${formatted || 'No resorts match your criteria.'}`,
+                        },
+                    ],
+                };
+            }
+            case 'get_snow_history': {
+                const data = await fetchAPI(`/resorts/${args?.slug}`);
+                const resort = data.data;
+                if (!resort) {
+                    return {
+                        content: [{ type: 'text', text: `Resort "${args?.slug}" not found.` }],
+                    };
+                }
+                const historic = resort.historic || {};
+                const snow = resort.snow || {};
+                const fiveYearAvg = historic.fiveYearAverage || 'N/A';
+                const thirtyYearAvg = historic.thirtyYearAverage || 'N/A';
+                const seasonTotal = snow.seasonTotal?.cm || 0;
+                let comparison = '';
+                if (typeof fiveYearAvg === 'number' && seasonTotal > 0) {
+                    const pct5 = Math.round((seasonTotal / fiveYearAvg) * 100);
+                    comparison += `- vs 5-Year Avg: ${pct5}% (${pct5 > 100 ? '+' : ''}${seasonTotal - fiveYearAvg}cm)\n`;
+                }
+                if (typeof thirtyYearAvg === 'number' && seasonTotal > 0) {
+                    const pct30 = Math.round((seasonTotal / thirtyYearAvg) * 100);
+                    comparison += `- vs 30-Year Avg: ${pct30}% (${pct30 > 100 ? '+' : ''}${seasonTotal - thirtyYearAvg}cm)\n`;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Snow History: ${resort.name}\n\n` +
+                                `## This Season\n` +
+                                `- **Season Total:** ${seasonTotal}cm\n` +
+                                `- **Last 7 Days:** ${snow.last7d?.cm || 0}cm\n` +
+                                `- **Last 24h:** ${snow.last24h?.cm || 0}cm\n\n` +
+                                `## Historical Averages\n` +
+                                `- **5-Year Average:** ${fiveYearAvg}cm\n` +
+                                `- **30-Year Average:** ${thirtyYearAvg}cm\n\n` +
+                                `## Season Comparison\n${comparison || 'Not enough data for comparison.'}\n\n` +
+                                `## Best Months to Visit\n` +
+                                `${historic.bestMonths?.join(', ') || 'January, February, March (typical)'}\n\n` +
+                                `${historic.trend ? `## Historical Trend\n${historic.trend}` : ''}`
+                        },
+                    ],
+                };
+            }
+            case 'plan_ski_trip': {
+                const data = await fetchAPI('/snow-report?sort=snowsure&limit=50');
+                let resorts = data.data?.resorts || data.data || [];
+                // Filter by region
+                if (args?.region && args.region !== 'any') {
+                    const regionMap = {
+                        'europe': ['Switzerland', 'France', 'Austria', 'Italy', 'Germany', 'Norway'],
+                        'north-america': ['United States', 'Canada'],
+                        'asia': ['Japan'],
+                    };
+                    const countries = regionMap[args.region] || [];
+                    if (countries.length > 0) {
+                        resorts = resorts.filter((r) => countries.includes(r.country));
+                    }
+                }
+                // Get top recommendations
+                const recommendations = resorts.slice(0, 5);
+                const formatted = recommendations.map((r, i) => `### ${i + 1}. ${r.name} (${r.country})\n` +
+                    `- **SnowSure Score:** ${r.snowSure?.score || 'N/A'}/100 - ${r.snowSure?.rating || 'N/A'}\n` +
+                    `- **Current Depth:** ${r.conditions?.snowDepthCm || 'N/A'}cm\n` +
+                    `- **14-Day Forecast:** ${Math.round(r.conditions?.forecast14dCm || 0)}cm expected\n` +
+                    `- **Why:** ${r.snowSure?.tagline || 'Great conditions'}`).join('\n\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# 🎿 Ski Trip Recommendations\n\n` +
+                                `**Region:** ${args?.region || 'Worldwide'}\n` +
+                                `**Dates:** ${args?.dates || 'Flexible'}\n` +
+                                `**Level:** ${args?.level || 'All levels'}\n\n` +
+                                `## Top Picks\n\n${formatted}\n\n` +
+                                `## Tips\n` +
+                                `- Book accommodation 2-4 weeks ahead for best rates\n` +
+                                `- Check forecasts 7 days before departure\n` +
+                                `- Consider mid-week dates for shorter lift lines\n` +
+                                `- SnowSure scores above 50 indicate excellent conditions`,
+                        },
+                    ],
+                };
+            }
+            case 'get_webcam_status': {
+                const data = await fetchAPI(`/resorts/${args?.slug}`);
+                const resort = data.data;
+                if (!resort) {
+                    return {
+                        content: [{ type: 'text', text: `Resort "${args?.slug}" not found.` }],
+                    };
+                }
+                const webcams = resort.webcams || [];
+                const webcamPage = resort.links?.webcamPage;
+                if (!webcams.length && !webcamPage) {
+                    return {
+                        content: [{ type: 'text', text: `No webcam data available for ${resort.name}.` }],
+                    };
+                }
+                const formatted = webcams.map((cam) => `- **${cam.name || 'Webcam'}**\n` +
+                    `  URL: ${cam.url || cam.embedUrl || 'N/A'}\n` +
+                    `  ${cam.thumbnailUrl ? `Thumbnail: ${cam.thumbnailUrl}` : ''}`).join('\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Webcams: ${resort.name}\n\n` +
+                                `${webcams.length ? formatted : 'Individual webcams not indexed.'}\n\n` +
+                                `${webcamPage ? `**Resort Webcam Page:** ${webcamPage}` : ''}\n\n` +
+                                `*View live at: https://snowsure.ai/resorts/${resort.slug}#webcams*`,
+                        },
+                    ],
+                };
+            }
+            case 'get_regional_summary': {
+                const data = await fetchAPI('/resorts?limit=200');
+                let resorts = data.data || [];
+                // Filter by region or country
+                if (args?.region) {
+                    const regionMap = {
+                        'europe': ['Switzerland', 'France', 'Austria', 'Italy', 'Germany', 'Norway', 'Sweden'],
+                        'north-america': ['United States', 'Canada'],
+                        'asia': ['Japan', 'South Korea'],
+                        'alps': ['Switzerland', 'France', 'Austria', 'Italy'],
+                        'rockies': ['United States', 'Canada'],
+                        'japan': ['Japan'],
+                    };
+                    const countries = regionMap[args.region] || [];
+                    if (countries.length > 0) {
+                        resorts = resorts.filter((r) => countries.includes(r.country));
+                    }
+                }
+                if (args?.country) {
+                    resorts = resorts.filter((r) => r.country?.toLowerCase() === args.country.toLowerCase());
+                }
+                // Calculate stats
+                const totalResorts = resorts.length;
+                const withSnow = resorts.filter((r) => (r.conditions?.snowDepthCm || 0) > 0).length;
+                const avgDepth = resorts.reduce((sum, r) => sum + (r.conditions?.snowDepthCm || 0), 0) / totalResorts;
+                const avgScore = resorts.reduce((sum, r) => sum + (r.snowSure?.score || 0), 0) / totalResorts;
+                const totalFresh = resorts.reduce((sum, r) => sum + (r.conditions?.snowfall24hCm || 0), 0);
+                // Top resorts
+                const topByScore = [...resorts].sort((a, b) => (b.snowSure?.score || 0) - (a.snowSure?.score || 0)).slice(0, 5);
+                const topBySnow = [...resorts].sort((a, b) => (b.conditions?.snowfall24hCm || 0) - (a.conditions?.snowfall24hCm || 0)).slice(0, 5);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Regional Summary: ${args?.region || args?.country || 'Global'}\n\n` +
+                                `## Statistics\n` +
+                                `- **Total Resorts:** ${totalResorts}\n` +
+                                `- **Resorts with Snow:** ${withSnow}\n` +
+                                `- **Average Depth:** ${avgDepth.toFixed(0)}cm\n` +
+                                `- **Average SnowSure Score:** ${avgScore.toFixed(0)}/100\n` +
+                                `- **Fresh Snow (24h total):** ${totalFresh.toFixed(0)}cm across region\n\n` +
+                                `## Top by SnowSure Score\n` +
+                                topByScore.map((r, i) => `${i + 1}. ${r.name} - ${r.snowSure?.score || 'N/A'}/100`).join('\n') +
+                                `\n\n## Most Fresh Snow (24h)\n` +
+                                topBySnow.filter((r) => r.conditions?.snowfall24hCm > 0).map((r, i) => `${i + 1}. ${r.name} - +${r.conditions?.snowfall24hCm}cm`).join('\n') || 'No fresh snow reported',
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// List available resources
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+        {
+            uri: 'snowsure://snow-report',
+            name: 'Global Snow Report',
+            description: 'Current snow conditions and rankings for top 50 resorts worldwide',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'snowsure://resorts',
+            name: 'All Resorts',
+            description: 'Complete list of 500+ ski resorts with current conditions',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'snowsure://regions',
+            name: 'Available Regions',
+            description: 'List of regions and countries with resort counts',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'snowsure://api-docs',
+            name: 'API Documentation',
+            description: 'OpenAPI specification for the SnowSure API',
+            mimeType: 'application/json',
+        },
+    ],
+}));
+// Read resources
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    switch (uri) {
+        case 'snowsure://snow-report': {
+            const data = await fetchAPI('/snow-report?limit=50');
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(data.data, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'snowsure://resorts': {
+            const data = await fetchAPI('/resorts?limit=500');
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(data.data, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'snowsure://regions': {
+            const data = await fetchAPI('/resorts?limit=500');
+            const resorts = data.data || [];
+            // Group by country and region
+            const byCountry = {};
+            const byRegion = {
+                'europe': [],
+                'north-america': [],
+                'asia': [],
+                'oceania': [],
+            };
+            resorts.forEach((r) => {
+                byCountry[r.country] = (byCountry[r.country] || 0) + 1;
+                // Map to regions
+                if (['Switzerland', 'France', 'Austria', 'Italy', 'Germany', 'Norway', 'Sweden'].includes(r.country)) {
+                    if (!byRegion['europe'].includes(r.country))
+                        byRegion['europe'].push(r.country);
+                }
+                else if (['United States', 'Canada'].includes(r.country)) {
+                    if (!byRegion['north-america'].includes(r.country))
+                        byRegion['north-america'].push(r.country);
+                }
+                else if (['Japan'].includes(r.country)) {
+                    if (!byRegion['asia'].includes(r.country))
+                        byRegion['asia'].push(r.country);
+                }
+                else if (['New Zealand', 'Australia'].includes(r.country)) {
+                    if (!byRegion['oceania'].includes(r.country))
+                        byRegion['oceania'].push(r.country);
+                }
+            });
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            totalResorts: resorts.length,
+                            byCountry,
+                            byRegion,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        case 'snowsure://api-docs': {
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            openapi: '3.1.0',
+                            info: {
+                                title: 'SnowSure API',
+                                version: '3.0.0',
+                                description: 'Real-time snow conditions for 220+ ski resorts worldwide. Data sourced from SnowSure\'s Sanity database with multi-model weather forecasts.',
+                            },
+                            servers: [{ url: 'https://www.snowsure.ai/api/v1' }],
+                            endpoints: {
+                                '/resorts': 'List all resorts with current conditions',
+                                '/resorts/{slug}': 'Get detailed resort information including forecasts',
+                                '/snow-report': 'Get global snow rankings sorted by various criteria',
+                            },
+                            website: 'https://www.snowsure.ai',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        default:
+            throw new Error(`Unknown resource: ${uri}`);
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('SnowSure MCP server v3.0 running');
+    console.error('API: https://www.snowsure.ai/api/v1');
+    console.error('Tools: 11 | Resources: 4');
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "snowsure-mcp-server",
+  "version": "3.0.1",
+  "description": "MCP server for ski resort snow: real-time powder rankings, 14-day forecasts, 500+ resorts — SnowSure.ai (Cursor, Claude, AI agents)",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "snowsure-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "watch": "tsc --watch"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cursor",
+    "claude",
+    "openai",
+    "ski",
+    "ski-resort",
+    "snow",
+    "powder",
+    "weather",
+    "forecast",
+    "snowsure"
+  ],
+  "author": "SnowSure",
+  "license": "MIT",
+  "homepage": "https://www.snowsure.ai/developers",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mikeslone/snowsure-web.git",
+    "directory": "mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/mikeslone/snowsure-web/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}