hotelzero 1.6.0 → 1.8.0

package/README.md

@@ -25,6 +25,30 @@ Or run directly with npx:
 npx hotelzero
 ```
 
+## Proxy Support
+
+For heavy usage or to avoid IP blocks, you can configure a proxy server via the `HOTELZERO_PROXY` environment variable:
+
+```bash
+# HTTP proxy
+HOTELZERO_PROXY=http://proxy.example.com:8080 npx hotelzero
+
+# HTTP proxy with authentication
+HOTELZERO_PROXY=http://user:pass@proxy.example.com:8080 npx hotelzero
+
+# SOCKS5 proxy
+HOTELZERO_PROXY=socks5://proxy.example.com:1080 npx hotelzero
+
+# SOCKS5 proxy with authentication
+HOTELZERO_PROXY=socks5://user:pass@proxy.example.com:1080 npx hotelzero
+```
+
+When a proxy is configured, you'll see confirmation in the startup logs:
+```
+Proxy enabled: http://proxy.example.com:8080
+HotelZero v1.8.0 running on stdio
+```
+
 ## Quick Start
 
 ### Run as MCP Server
@@ -516,6 +540,14 @@ Run `npx playwright install chromium` to install the browser.
 
 - Wait a few minutes before retrying
 - The server uses anti-detection measures, but excessive requests may trigger blocks
+- Consider using a proxy server (see [Proxy Support](#proxy-support))
+
+### Proxy not working
+
+- Verify the proxy server is running and accessible
+- Check credentials if using authentication
+- Ensure the proxy supports HTTPS connections
+- Try a different proxy or test without proxy first
 
 ---
 

package/dist/browser.d.ts

@@ -1,3 +1,8 @@
+export interface ProxyConfig {
+    server: string;
+    username?: string;
+    password?: string;
+}
 export declare class HotelSearchError extends Error {
     code: string;
     retryable: boolean;
@@ -199,12 +204,42 @@ export interface ReviewsResult {
     reviews: Review[];
     url: string;
 }
+export interface DatePrice {
+    date: string;
+    price: number | null;
+    priceDisplay: string;
+    available: boolean;
+    currency: string;
+}
+export interface PriceCalendarResult {
+    hotelName: string;
+    startDate: string;
+    endDate: string;
+    nights: number;
+    currency: string;
+    prices: DatePrice[];
+    lowestPrice: number | null;
+    lowestPriceDate: string | null;
+    highestPrice: number | null;
+    highestPriceDate: string | null;
+    averagePrice: number | null;
+    url: string;
+}
 export declare class HotelBrowser {
     private browser;
     private page;
     private lastRequestTime;
     private minRequestIntervalMs;
-    init(headless?: boolean): Promise<void>;
+    private proxyConfig;
+    init(headless?: boolean, proxy?: ProxyConfig): Promise<void>;
+    /**
+     * Check if a proxy is configured
+     */
+    hasProxy(): boolean;
+    /**
+     * Get the current proxy server (without credentials)
+     */
+    getProxyServer(): string | null;
     close(): Promise<void>;
     private buildBookingUrl;
     private enforceRateLimit;
@@ -240,4 +275,8 @@ export declare class HotelBrowser {
      * Get reviews for a specific hotel
      */
     getReviews(hotelUrl: string, limit?: number, sortBy?: "recent" | "highest" | "lowest", filterBy?: "couples" | "families" | "solo" | "business" | "groups"): Promise<ReviewsResult>;
+    /**
+     * Get price calendar for a hotel - shows prices for multiple dates
+     */
+    getPriceCalendar(hotelUrl: string, startDate: string, nights?: number, guests?: number, rooms?: number, currency?: string): Promise<PriceCalendarResult>;
 }

package/dist/browser.js

@@ -232,17 +232,42 @@ export class HotelBrowser {
     page = null;
     lastRequestTime = 0;
     minRequestIntervalMs = 2000; // Minimum 2 seconds between requests
-    async init(headless = true) {
-        this.browser = await chromium.launch({
+    proxyConfig = null;
+    async init(headless = true, proxy) {
+        // Store proxy config for reference
+        this.proxyConfig = proxy || null;
+        // Build launch options
+        const launchOptions = {
             headless,
             args: ["--disable-blink-features=AutomationControlled"],
-        });
+        };
+        // Add proxy to launch options if provided
+        if (proxy) {
+            launchOptions.proxy = {
+                server: proxy.server,
+                username: proxy.username,
+                password: proxy.password,
+            };
+        }
+        this.browser = await chromium.launch(launchOptions);
         const context = await this.browser.newContext({
             userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
             viewport: { width: 1280, height: 900 },
         });
         this.page = await context.newPage();
     }
+    /**
+     * Check if a proxy is configured
+     */
+    hasProxy() {
+        return this.proxyConfig !== null;
+    }
+    /**
+     * Get the current proxy server (without credentials)
+     */
+    getProxyServer() {
+        return this.proxyConfig?.server || null;
+    }
     async close() {
         if (this.browser) {
             await this.browser.close();
@@ -1747,4 +1772,184 @@ export class HotelBrowser {
             console.error(`Get reviews attempt ${attempt} failed: ${error.message}. Retrying in ${Math.round(delayMs / 1000)}s...`);
         });
     }
+    /**
+     * Get price calendar for a hotel - shows prices for multiple dates
+     */
+    async getPriceCalendar(hotelUrl, startDate, nights = 14, guests = 2, rooms = 1, currency = "USD") {
+        // Validate inputs
+        const start = new Date(startDate);
+        if (isNaN(start.getTime())) {
+            throw new Error("Invalid start date format. Use YYYY-MM-DD.");
+        }
+        // Limit to reasonable range
+        const actualNights = Math.min(Math.max(nights, 1), 30);
+        // Generate date range
+        const dates = [];
+        for (let i = 0; i < actualNights; i++) {
+            const checkIn = new Date(start);
+            checkIn.setDate(checkIn.getDate() + i);
+            const checkOut = new Date(checkIn);
+            checkOut.setDate(checkOut.getDate() + 1);
+            dates.push({
+                checkIn: checkIn.toISOString().split("T")[0],
+                checkOut: checkOut.toISOString().split("T")[0],
+            });
+        }
+        // Clean the hotel URL
+        const cleanUrl = hotelUrl.split("?")[0].split("#")[0];
+        // Collect prices for each date
+        const prices = [];
+        let hotelName = "";
+        for (const dateRange of dates) {
+            await this.enforceRateLimit();
+            if (!this.page)
+                throw new Error("Browser not initialized");
+            const urlWithDates = `${cleanUrl}?checkin=${dateRange.checkIn}&checkout=${dateRange.checkOut}&group_adults=${guests}&no_rooms=${rooms}&selected_currency=${currency}`;
+            try {
+                await this.page.goto(urlWithDates, {
+                    waitUntil: "domcontentloaded",
+                    timeout: 30000,
+                });
+                await this.page.waitForTimeout(2000);
+                // Close any popups
+                try {
+                    await this.page.keyboard.press("Escape");
+                }
+                catch { }
+                // Extract price data
+                const priceData = await this.page.evaluate(`
+          (function() {
+            var result = { hotelName: '', price: null, priceDisplay: '', available: true, currency: '' };
+            
+            // Get hotel name (only need it once)
+            var nameEl = document.querySelector('h2[class*="pp-header__title"], [data-testid="PropertyHeaderDesktop-wrapper"] h2, h2.d2fee87262');
+            result.hotelName = nameEl?.textContent?.trim() || '';
+            
+            // Check for no availability message
+            var noAvail = document.querySelector('[class*="soldout"], [class*="no-availability"], [data-testid="no-rooms-available"]');
+            if (noAvail) {
+              result.available = false;
+              return result;
+            }
+            
+            // Find the lowest price - look for price elements
+            var priceElements = document.querySelectorAll('[data-testid="price-and-discounted-price"], .bui-price-display__value, .prco-valign-middle-helper');
+            var prices = [];
+            
+            priceElements.forEach(function(el) {
+              var text = el.textContent?.trim() || '';
+              // Extract price number and currency
+              var match = text.match(/([\\$€£¥₹])\\s*([\\d,]+)/);
+              if (match) {
+                var currencySymbol = match[1];
+                var priceNum = parseInt(match[2].replace(/,/g, ''));
+                if (!isNaN(priceNum) && priceNum > 0) {
+                  prices.push({ price: priceNum, display: text.trim(), currency: currencySymbol });
+                }
+              }
+              // Also try format like "241 $" or "241 USD"
+              var match2 = text.match(/([\\d,]+)\\s*([\\$€£¥₹]|USD|EUR|GBP)/);
+              if (match2) {
+                var priceNum2 = parseInt(match2[1].replace(/,/g, ''));
+                if (!isNaN(priceNum2) && priceNum2 > 0) {
+                  prices.push({ price: priceNum2, display: text.trim(), currency: match2[2] });
+                }
+              }
+            });
+            
+            // Get the lowest price
+            if (prices.length > 0) {
+              prices.sort(function(a, b) { return a.price - b.price; });
+              result.price = prices[0].price;
+              result.priceDisplay = prices[0].display;
+              result.currency = prices[0].currency;
+            } else {
+              // Try alternative price selectors
+              var altPrice = document.querySelector('[class*="bui-price-display"], [class*="price"]');
+              if (altPrice) {
+                var altText = altPrice.textContent?.trim() || '';
+                var altMatch = altText.match(/([\\$€£¥₹])\\s*([\\d,]+)/);
+                if (altMatch) {
+                  result.price = parseInt(altMatch[2].replace(/,/g, ''));
+                  result.priceDisplay = altMatch[0];
+                  result.currency = altMatch[1];
+                }
+              }
+            }
+            
+            // If still no price found, might be unavailable
+            if (result.price === null) {
+              result.available = false;
+            }
+            
+            return result;
+          })()
+        `);
+                // Store hotel name from first result
+                if (!hotelName && priceData.hotelName) {
+                    hotelName = priceData.hotelName;
+                }
+                // Map currency symbol to code
+                const currencyMap = {
+                    "$": "USD",
+                    "€": "EUR",
+                    "£": "GBP",
+                    "¥": "JPY",
+                    "₹": "INR",
+                };
+                const currencyCode = currencyMap[priceData.currency] || priceData.currency || currency;
+                prices.push({
+                    date: dateRange.checkIn,
+                    price: priceData.price,
+                    priceDisplay: priceData.priceDisplay || (priceData.price ? `${priceData.currency}${priceData.price}` : "N/A"),
+                    available: priceData.available,
+                    currency: currencyCode,
+                });
+            }
+            catch (error) {
+                // If page load fails, mark as unavailable
+                prices.push({
+                    date: dateRange.checkIn,
+                    price: null,
+                    priceDisplay: "Error",
+                    available: false,
+                    currency,
+                });
+            }
+        }
+        // Calculate statistics
+        const availablePrices = prices.filter(p => p.price !== null && p.available);
+        const priceValues = availablePrices.map(p => p.price);
+        let lowestPrice = null;
+        let lowestPriceDate = null;
+        let highestPrice = null;
+        let highestPriceDate = null;
+        let averagePrice = null;
+        if (priceValues.length > 0) {
+            lowestPrice = Math.min(...priceValues);
+            highestPrice = Math.max(...priceValues);
+            averagePrice = Math.round(priceValues.reduce((a, b) => a + b, 0) / priceValues.length);
+            const lowestPriceEntry = availablePrices.find(p => p.price === lowestPrice);
+            const highestPriceEntry = availablePrices.find(p => p.price === highestPrice);
+            lowestPriceDate = lowestPriceEntry?.date || null;
+            highestPriceDate = highestPriceEntry?.date || null;
+        }
+        // Calculate end date
+        const endDate = new Date(start);
+        endDate.setDate(endDate.getDate() + actualNights - 1);
+        return {
+            hotelName,
+            startDate,
+            endDate: endDate.toISOString().split("T")[0],
+            nights: actualNights,
+            currency,
+            prices,
+            lowestPrice,
+            lowestPriceDate,
+            highestPrice,
+            highestPriceDate,
+            averagePrice,
+            url: cleanUrl,
+        };
+    }
 }

package/dist/index.js

@@ -139,12 +139,55 @@ const GetReviewsSchema = z.object({
     sortBy: z.enum(["recent", "highest", "lowest"]).optional().describe("Sort reviews by: recent (default), highest score, or lowest score"),
     filterBy: z.enum(["couples", "families", "solo", "business", "groups"]).optional().describe("Filter reviews by traveler type"),
 });
+const GetPriceCalendarSchema = z.object({
+    hotelUrl: z.string().describe("Booking.com hotel URL to get prices for"),
+    startDate: z.string().describe("Start date for price calendar (YYYY-MM-DD)"),
+    nights: z.number().min(1).max(30).optional().describe("Number of nights to check (default: 14, max: 30)"),
+    guests: z.number().min(1).max(30).optional().describe("Number of guests (default: 2)"),
+    rooms: z.number().min(1).max(10).optional().describe("Number of rooms (default: 1)"),
+    currency: z.string().optional().describe("Currency code (default: USD)"),
+});
 // Global browser instance (reuse for efficiency)
 let browser = null;
+/**
+ * Parse proxy configuration from environment variable
+ * Supports formats:
+ *   - http://proxy.example.com:8080
+ *   - http://user:pass@proxy.example.com:8080
+ *   - socks5://proxy.example.com:1080
+ *   - socks5://user:pass@proxy.example.com:1080
+ */
+function parseProxyFromEnv() {
+    const proxyUrl = process.env.HOTELZERO_PROXY;
+    if (!proxyUrl)
+        return undefined;
+    try {
+        const url = new URL(proxyUrl);
+        const config = {
+            server: `${url.protocol}//${url.host}`,
+        };
+        if (url.username) {
+            config.username = decodeURIComponent(url.username);
+        }
+        if (url.password) {
+            config.password = decodeURIComponent(url.password);
+        }
+        return config;
+    }
+    catch (error) {
+        console.error(`Invalid HOTELZERO_PROXY format: ${proxyUrl}`);
+        return undefined;
+    }
+}
 async function getBrowser() {
     if (!browser) {
         browser = new HotelBrowser();
-        await browser.init(true);
+        const proxyConfig = parseProxyFromEnv();
+        await browser.init(true, proxyConfig);
+        // Log proxy status (without credentials)
+        if (browser.hasProxy()) {
+            console.error(`Proxy enabled: ${browser.getProxyServer()}`);
+        }
     }
     return browser;
 }
@@ -438,10 +481,72 @@ function formatReviewsResult(result) {
     lines.push(`Hotel URL: ${result.url}`);
     return lines.join("\n");
 }
+function formatPriceCalendarResult(result) {
+    const lines = [];
+    lines.push("=".repeat(60));
+    lines.push(`PRICE CALENDAR: ${result.hotelName}`);
+    lines.push("=".repeat(60));
+    lines.push("");
+    lines.push(`Date Range: ${result.startDate} to ${result.endDate} (${result.nights} nights)`);
+    lines.push(`Currency: ${result.currency}`);
+    lines.push("");
+    // Summary statistics
+    lines.push("--- SUMMARY ---");
+    if (result.lowestPrice !== null) {
+        lines.push(`Lowest Price:  ${result.currency} ${result.lowestPrice} (${result.lowestPriceDate})`);
+    }
+    if (result.highestPrice !== null) {
+        lines.push(`Highest Price: ${result.currency} ${result.highestPrice} (${result.highestPriceDate})`);
+    }
+    if (result.averagePrice !== null) {
+        lines.push(`Average Price: ${result.currency} ${result.averagePrice}`);
+    }
+    const availableCount = result.prices.filter(p => p.available).length;
+    const unavailableCount = result.prices.length - availableCount;
+    lines.push(`Available: ${availableCount}/${result.prices.length} nights`);
+    if (unavailableCount > 0) {
+        lines.push(`Unavailable: ${unavailableCount} nights`);
+    }
+    lines.push("");
+    // Price calendar
+    lines.push("--- PRICES BY DATE ---");
+    // Group by week for better readability
+    let currentWeek = [];
+    let lastWeekNum = -1;
+    result.prices.forEach((datePrice) => {
+        const date = new Date(datePrice.date);
+        const dayName = date.toLocaleDateString('en-US', { weekday: 'short' });
+        const monthDay = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+        let priceStr;
+        if (!datePrice.available) {
+            priceStr = "N/A";
+        }
+        else if (datePrice.price !== null) {
+            // Highlight lowest price
+            if (datePrice.price === result.lowestPrice) {
+                priceStr = `${datePrice.priceDisplay} ★ LOWEST`;
+            }
+            else if (datePrice.price === result.highestPrice) {
+                priceStr = `${datePrice.priceDisplay} (highest)`;
+            }
+            else {
+                priceStr = datePrice.priceDisplay;
+            }
+        }
+        else {
+            priceStr = "N/A";
+        }
+        lines.push(`${dayName} ${monthDay}: ${priceStr}`);
+    });
+    lines.push("");
+    lines.push("=".repeat(60));
+    lines.push(`Hotel URL: ${result.url}`);
+    return lines.join("\n");
+}
 // Create MCP server
 const server = new Server({
     name: "hotelzero",
-    version: "1.6.0",
+    version: "1.8.0",
 }, {
     capabilities: {
         tools: {},
@@ -658,6 +763,22 @@ Results are scored and ranked by how well they match the criteria.`,
                     required: ["hotelUrl"],
                 },
             },
+            {
+                name: "get_price_calendar",
+                description: "Get prices for a hotel across multiple dates to find the cheapest time to stay. Shows nightly prices, identifies the lowest/highest price dates, and calculates average pricing. Useful for flexible travelers looking for the best deal.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        hotelUrl: { type: "string", description: "Booking.com hotel URL to check prices for" },
+                        startDate: { type: "string", description: "Start date for price calendar (YYYY-MM-DD)" },
+                        nights: { type: "number", description: "Number of nights to check (default: 14, max: 30)", minimum: 1, maximum: 30 },
+                        guests: { type: "number", description: "Number of guests (default: 2)", minimum: 1, maximum: 30 },
+                        rooms: { type: "number", description: "Number of rooms (default: 1)", minimum: 1, maximum: 10 },
+                        currency: { type: "string", description: "Currency code (default: USD)" },
+                    },
+                    required: ["hotelUrl", "startDate"],
+                },
+            },
         ],
     };
 });
@@ -845,6 +966,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "get_price_calendar": {
+                const parsed = GetPriceCalendarSchema.parse(args);
+                const result = await b.getPriceCalendar(parsed.hotelUrl, parsed.startDate, parsed.nights, parsed.guests, parsed.rooms, parsed.currency);
+                const formatted = formatPriceCalendarResult(result);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatted,
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -913,7 +1047,7 @@ process.on("SIGTERM", async () => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("HotelZero v1.6.0 running on stdio");
+    console.error("HotelZero v1.8.0 running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hotelzero",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "MCP server for searching hotels on Booking.com with 80+ filters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",