hotelzero 1.4.0 → 1.6.0

package/dist/browser.d.ts

@@ -147,6 +147,58 @@ export interface HotelDetails {
     guestReviewHighlights: string[];
     locationInfo: string;
 }
+export interface RoomOption {
+    name: string;
+    price: number | null;
+    priceDisplay: string;
+    sleeps: number | null;
+    features: string[];
+    bedType: string;
+    cancellation: string;
+    breakfast: string;
+}
+export interface AvailabilityResult {
+    available: boolean;
+    hotelName: string;
+    checkIn: string;
+    checkOut: string;
+    guests: number;
+    rooms: number;
+    roomOptions: RoomOption[];
+    lowestPrice: number | null;
+    lowestPriceDisplay: string;
+    message: string;
+    url: string;
+}
+export interface Review {
+    title: string;
+    rating: number | null;
+    date: string;
+    travelerType: string;
+    country: string;
+    stayDate: string;
+    roomType: string;
+    nightsStayed: string;
+    positive: string;
+    negative: string;
+}
+export interface RatingBreakdown {
+    staff: number | null;
+    facilities: number | null;
+    cleanliness: number | null;
+    comfort: number | null;
+    valueForMoney: number | null;
+    location: number | null;
+    freeWifi: number | null;
+}
+export interface ReviewsResult {
+    hotelName: string;
+    overallRating: number | null;
+    totalReviews: number;
+    ratingBreakdown: RatingBreakdown;
+    reviews: Review[];
+    url: string;
+}
 export declare class HotelBrowser {
     private browser;
     private page;
@@ -174,4 +226,18 @@ export declare class HotelBrowser {
      * Compare multiple hotels side-by-side
      */
     compareHotels(hotelUrls: string[]): Promise<HotelDetails[]>;
+    /**
+     * Check availability for a specific hotel on given dates
+     */
+    checkAvailability(params: {
+        hotelUrl: string;
+        checkIn: string;
+        checkOut: string;
+        guests?: number;
+        rooms?: number;
+    }): Promise<AvailabilityResult>;
+    /**
+     * Get reviews for a specific hotel
+     */
+    getReviews(hotelUrl: string, limit?: number, sortBy?: "recent" | "highest" | "lowest", filterBy?: "couples" | "families" | "solo" | "business" | "groups"): Promise<ReviewsResult>;
 }

package/dist/browser.js

@@ -1243,4 +1243,508 @@ export class HotelBrowser {
         }
         return results;
     }
+    /**
+     * Check availability for a specific hotel on given dates
+     */
+    async checkAvailability(params) {
+        if (!this.page) {
+            throw new HotelSearchError("Browser not initialized. Call init() first.", ErrorCodes.BROWSER_NOT_INITIALIZED, false);
+        }
+        const { hotelUrl, checkIn, checkOut, guests = 2, rooms = 1 } = params;
+        // Validate dates
+        const checkInDate = new Date(checkIn);
+        const checkOutDate = new Date(checkOut);
+        if (isNaN(checkInDate.getTime()) || isNaN(checkOutDate.getTime())) {
+            throw new HotelSearchError("Invalid date format. Use YYYY-MM-DD.", "INVALID_INPUT", false);
+        }
+        if (checkOutDate <= checkInDate) {
+            throw new HotelSearchError("Check-out date must be after check-in date.", "INVALID_INPUT", false);
+        }
+        return await retryWithBackoff(async () => {
+            await this.enforceRateLimit();
+            // Build URL with date parameters
+            // Strip existing query params and add our own
+            const baseUrl = hotelUrl.split("?")[0];
+            const urlWithDates = `${baseUrl}?checkin=${checkIn}&checkout=${checkOut}&group_adults=${guests}&no_rooms=${rooms}&group_children=0`;
+            try {
+                await this.page.goto(urlWithDates, {
+                    waitUntil: "networkidle",
+                    timeout: 30000,
+                });
+            }
+            catch (error) {
+                const err = error;
+                if (err.message.includes("timeout") || err.message.includes("Timeout")) {
+                    throw new HotelSearchError("Page load timed out.", ErrorCodes.TIMEOUT, true);
+                }
+                throw new HotelSearchError(`Navigation failed: ${err.message}`, ErrorCodes.NAVIGATION_FAILED, true);
+            }
+            await this.page.waitForTimeout(2000);
+            await this.checkForBlocking();
+            await this.dismissPopups();
+            // Extract room availability using string-based evaluate
+            const result = await this.page.evaluate(`
+          (function() {
+            function getText(selector) {
+              var el = document.querySelector(selector);
+              return el && el.textContent ? el.textContent.trim() : "";
+            }
+
+            // Get hotel name
+            var hotelName = getText('h2') || getText('h1').split('(')[0].trim() || "Unknown Hotel";
+
+            var roomOptions = [];
+            var seenRooms = {};
+            
+            // Strategy 1: Look for room type links (most reliable on Booking.com)
+            var roomTypeLinks = document.querySelectorAll('.hprt-roomtype-link, a[class*="hprt-roomtype"]');
+            
+            for (var i = 0; i < roomTypeLinks.length && roomOptions.length < 10; i++) {
+              var roomLink = roomTypeLinks[i];
+              var name = roomLink.textContent.trim();
+              
+              if (!name || name.length < 3 || seenRooms[name]) continue;
+              seenRooms[name] = true;
+              
+              // Find the containing row to get price and details
+              var row = roomLink.closest('tr') || roomLink.closest('[data-block-id]') || roomLink.parentElement;
+              var rowText = row ? row.textContent || "" : "";
+              
+              // Try to find price in the same row or nearby
+              var price = null;
+              var priceDisplay = "";
+              
+              // Look for price cell in this row or next siblings
+              var priceCell = row ? row.querySelector('.hprt-table-cell-price, [class*="price-block"], [class*="bui-price"]') : null;
+              if (priceCell) {
+                priceDisplay = priceCell.textContent.trim();
+                var match = priceDisplay.match(/[\\$€£¥]\\s*([\\d,]+)/);
+                if (match) {
+                  price = parseInt(match[1].replace(/,/g, ""));
+                  // Clean up price display
+                  var perNightMatch = priceDisplay.match(/[\\$€£¥]\\s*[\\d,]+/);
+                  priceDisplay = perNightMatch ? perNightMatch[0] : priceDisplay.split('\\n')[0];
+                }
+              }
+              
+              // If no price found in row, search in sibling rows with same room type
+              if (!price) {
+                var allPriceCells = document.querySelectorAll('.hprt-table-cell-price');
+                for (var j = 0; j < allPriceCells.length && !price; j++) {
+                  var cellText = allPriceCells[j].textContent || "";
+                  var match = cellText.match(/[\\$€£¥]\\s*([\\d,]+)/);
+                  if (match) {
+                    price = parseInt(match[1].replace(/,/g, ""));
+                    priceDisplay = match[0];
+                    break;
+                  }
+                }
+              }
+              
+              // Bed type - clean up multiline text
+              var bedType = "";
+              var bedEl = row ? row.querySelector('.hprt-roomtype-bed, [class*="bed-type"]') : null;
+              if (bedEl) {
+                // Get first meaningful line
+                var bedText = bedEl.textContent || "";
+                var bedLines = bedText.split('\\n').map(function(l) { return l.trim(); }).filter(function(l) { return l.length > 0; });
+                // Find line with bed info
+                for (var k = 0; k < bedLines.length; k++) {
+                  if (bedLines[k].match(/(bed|queen|king|twin|double|single|sofa)/i)) {
+                    bedType = bedLines[k];
+                    break;
+                  }
+                }
+                if (!bedType && bedLines.length > 0) {
+                  bedType = bedLines[0];
+                }
+              }
+              
+              // Cancellation
+              var cancellation = "";
+              if (rowText.toLowerCase().indexOf("free cancellation") >= 0) {
+                cancellation = "Free cancellation";
+              } else if (rowText.toLowerCase().indexOf("non-refundable") >= 0) {
+                cancellation = "Non-refundable";
+              }
+              
+              // Breakfast
+              var breakfast = "";
+              if (rowText.toLowerCase().indexOf("breakfast included") >= 0) {
+                breakfast = "Breakfast included";
+              } else if (rowText.toLowerCase().indexOf("room only") >= 0) {
+                breakfast = "Room only";
+              }
+              
+              // Occupancy
+              var sleeps = null;
+              var occupancyEl = row ? row.querySelector('[class*="occupancy"], .hprt-occupancy-occupancy-info') : null;
+              if (occupancyEl) {
+                var occMatch = occupancyEl.textContent.match(/(\\d+)/);
+                sleeps = occMatch ? parseInt(occMatch[1]) : null;
+              }
+              
+              roomOptions.push({
+                name: name,
+                price: price,
+                priceDisplay: priceDisplay,
+                sleeps: sleeps,
+                features: [],
+                bedType: bedType,
+                cancellation: cancellation,
+                breakfast: breakfast
+              });
+            }
+            
+            // Strategy 2: If no rooms found, try data-block-id elements
+            if (roomOptions.length === 0) {
+              var blocks = document.querySelectorAll('[data-block-id]');
+              for (var i = 0; i < blocks.length && roomOptions.length < 10; i++) {
+                var block = blocks[i];
+                var blockText = block.textContent || "";
+                
+                // Look for any room name pattern
+                var nameEl = block.querySelector('a[class*="room"], span[class*="room-name"]');
+                var name = nameEl ? nameEl.textContent.trim() : "";
+                
+                if (!name) {
+                  // Try to extract from block text
+                  var lines = blockText.split('\\n').filter(function(l) { return l.trim().length > 0; });
+                  name = lines[0] ? lines[0].trim().slice(0, 50) : "";
+                }
+                
+                if (!name || name.length < 3 || seenRooms[name]) continue;
+                seenRooms[name] = true;
+                
+                var priceMatch = blockText.match(/[\\$€£¥]\\s*([\\d,]+)/);
+                var price = priceMatch ? parseInt(priceMatch[1].replace(/,/g, "")) : null;
+                
+                roomOptions.push({
+                  name: name,
+                  price: price,
+                  priceDisplay: priceMatch ? priceMatch[0] : "",
+                  sleeps: null,
+                  features: [],
+                  bedType: "",
+                  cancellation: "",
+                  breakfast: ""
+                });
+              }
+            }
+            
+            // Check for "no availability" message
+            var bodyText = document.body.textContent || "";
+            var noAvailability = 
+              bodyText.indexOf("no availability") >= 0 ||
+              bodyText.indexOf("sold out") >= 0 ||
+              bodyText.indexOf("no rooms available") >= 0 ||
+              bodyText.indexOf("fully booked") >= 0 ||
+              bodyText.indexOf("We have no availability") >= 0;
+            
+            return {
+              hotelName: hotelName,
+              roomOptions: roomOptions,
+              noAvailabilityDetected: noAvailability && roomOptions.length === 0
+            };
+          })()
+        `);
+            // Determine availability and lowest price
+            const available = result.roomOptions.length > 0 && !result.noAvailabilityDetected;
+            const prices = result.roomOptions
+                .map(r => r.price)
+                .filter((p) => p !== null);
+            const lowestPrice = prices.length > 0 ? Math.min(...prices) : null;
+            const lowestPriceRoom = result.roomOptions.find(r => r.price === lowestPrice);
+            // Build message
+            let message;
+            if (!available) {
+                message = "No rooms available for the selected dates.";
+            }
+            else if (result.roomOptions.length === 1) {
+                message = `1 room type available${lowestPrice ? ` from ${lowestPriceRoom?.priceDisplay || '$' + lowestPrice}` : ''}.`;
+            }
+            else {
+                message = `${result.roomOptions.length} room types available${lowestPrice ? ` from ${lowestPriceRoom?.priceDisplay || '$' + lowestPrice}` : ''}.`;
+            }
+            return {
+                available,
+                hotelName: result.hotelName,
+                checkIn,
+                checkOut,
+                guests,
+                rooms,
+                roomOptions: result.roomOptions,
+                lowestPrice,
+                lowestPriceDisplay: lowestPriceRoom?.priceDisplay || "",
+                message,
+                url: urlWithDates,
+            };
+        }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
+            console.error(`Check availability attempt ${attempt} failed: ${error.message}. Retrying in ${Math.round(delayMs / 1000)}s...`);
+        });
+    }
+    /**
+     * Get reviews for a specific hotel
+     */
+    async getReviews(hotelUrl, limit = 10, sortBy = "recent", filterBy) {
+        return retryWithBackoff(async () => {
+            await this.enforceRateLimit();
+            if (!this.page)
+                throw new Error("Browser not initialized");
+            // Navigate to hotel page
+            const cleanUrl = hotelUrl.split("?")[0].split("#")[0];
+            await this.page.goto(cleanUrl, {
+                waitUntil: "domcontentloaded",
+                timeout: 60000,
+            });
+            await this.page.waitForTimeout(3000);
+            // Close any popups
+            try {
+                const closeButtons = await this.page.$$('[aria-label="Dismiss sign-in info."], [data-testid="dismissButton"], button[aria-label*="close"], button[aria-label*="Close"]');
+                for (const btn of closeButtons) {
+                    try {
+                        await btn.click({ timeout: 1000 });
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+            await this.page.keyboard.press("Escape");
+            await this.page.waitForTimeout(500);
+            // Get overall rating info from main page before opening modal
+            const mainPageData = await this.page.evaluate(`
+          (function() {
+            var results = { hotelName: '', overallRating: null, totalReviews: 0, breakdown: {} };
+            
+            // Hotel name
+            var nameEl = document.querySelector('h2[class*="pp-header__title"], [data-testid="PropertyHeaderDesktop-wrapper"] h2, h2.d2fee87262');
+            results.hotelName = nameEl?.textContent?.trim() || '';
+            
+            // Overall rating and total reviews from review-score-component
+            var scoreComponent = document.querySelector('[data-testid="review-score-component"]');
+            if (scoreComponent) {
+              var text = scoreComponent.textContent || '';
+              // Extract score (e.g., "Scored 9.1 9.1..." -> 9.1)
+              var scoreMatch = text.match(/Scored\\s+([\\d.]+)/);
+              if (scoreMatch) {
+                results.overallRating = parseFloat(scoreMatch[1]);
+              }
+              // Extract total reviews (e.g., "1,043 reviews")
+              var reviewCountMatch = text.match(/([\\d,]+)\\s+reviews?/);
+              if (reviewCountMatch) {
+                results.totalReviews = parseInt(reviewCountMatch[1].replace(/,/g, ''));
+              }
+            }
+            
+            // Rating breakdown categories
+            var breakdownEls = document.querySelectorAll('[data-testid="review-subscore"]');
+            breakdownEls.forEach(function(el) {
+              var text = el.textContent?.trim() || '';
+              var parts = text.split(/\\s+/);
+              if (parts.length >= 2) {
+                var score = parseFloat(parts[parts.length - 1]);
+                var category = parts.slice(0, -1).join(' ').toLowerCase();
+                if (category.includes('staff')) results.breakdown.staff = score;
+                else if (category.includes('facilities')) results.breakdown.facilities = score;
+                else if (category.includes('cleanliness')) results.breakdown.cleanliness = score;
+                else if (category.includes('comfort')) results.breakdown.comfort = score;
+                else if (category.includes('value') || category.includes('money')) results.breakdown.valueForMoney = score;
+                else if (category.includes('location')) results.breakdown.location = score;
+                else if (category.includes('wifi') || category.includes('wi-fi')) results.breakdown.freeWifi = score;
+              }
+            });
+            
+            return results;
+          })()
+        `);
+            // Click "Read all reviews" button to open reviews modal
+            const readAllBtn = await this.page.$('[data-testid="fr-read-all-reviews"], [data-testid="review-score-read-all"]');
+            if (!readAllBtn) {
+                throw new Error("Could not find 'Read all reviews' button. Hotel may not have reviews.");
+            }
+            await readAllBtn.click();
+            await this.page.waitForTimeout(3000);
+            // Apply sort option if not default
+            if (sortBy !== "recent") {
+                try {
+                    const sorter = await this.page.$('[data-testid="reviews-sorter-component"]');
+                    if (sorter) {
+                        await sorter.click();
+                        await this.page.waitForTimeout(500);
+                        // Map our sortBy values to Booking.com's options
+                        const sortMap = {
+                            recent: "Newest first",
+                            highest: "Highest scores",
+                            lowest: "Lowest scores",
+                        };
+                        const sortOption = await this.page.$(`[role="option"]:has-text("${sortMap[sortBy]}")`);
+                        if (sortOption) {
+                            await sortOption.click();
+                            await this.page.waitForTimeout(2000);
+                        }
+                    }
+                }
+                catch { }
+            }
+            // Apply traveler type filter if specified
+            if (filterBy) {
+                try {
+                    const filterMap = {
+                        couples: "Couples",
+                        families: "Families",
+                        solo: "Solo travelers",
+                        business: "Business travelers",
+                        groups: "Groups of friends",
+                    };
+                    const filterLabel = await this.page.$(`[data-testid="customerType"] label:has-text("${filterMap[filterBy]}")`);
+                    if (filterLabel) {
+                        await filterLabel.click();
+                        await this.page.waitForTimeout(2000);
+                    }
+                }
+                catch { }
+            }
+            // Scroll down to ensure reviews are visible
+            await this.page.evaluate(`
+          (function() {
+            var reviewCards = document.querySelector('[data-testid="review-cards"]');
+            if (reviewCards) {
+              reviewCards.scrollIntoView({ behavior: 'instant', block: 'start' });
+            }
+          })()
+        `);
+            await this.page.waitForTimeout(1000);
+            // Scroll to load more reviews if needed (up to limit)
+            const targetReviews = Math.min(limit, 50);
+            let currentCount = 0;
+            let scrollAttempts = 0;
+            const maxScrollAttempts = Math.ceil(targetReviews / 10) + 3;
+            while (scrollAttempts < maxScrollAttempts) {
+                const count = await this.page.evaluate(`
+            document.querySelectorAll('[data-testid="review-card"]').length
+          `);
+                if (count >= targetReviews || count === currentCount) {
+                    break;
+                }
+                currentCount = count;
+                // Scroll within the modal/container
+                await this.page.evaluate(`
+            (function() {
+              var container = document.querySelector('[data-testid="review-list-container"]')
+                || document.querySelector('[role="dialog"]');
+              if (container) {
+                container.scrollTop = container.scrollHeight;
+              }
+              // Also scroll the last review into view
+              var reviews = document.querySelectorAll('[data-testid="review-card"]');
+              if (reviews.length > 0) {
+                reviews[reviews.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+              }
+            })()
+          `);
+                await this.page.waitForTimeout(1500);
+                scrollAttempts++;
+            }
+            // Extract reviews
+            const reviews = await this.page.evaluate(`
+          (function() {
+            var reviewCards = document.querySelectorAll('[data-testid="review-card"]');
+            var reviews = [];
+            
+            for (var i = 0; i < reviewCards.length; i++) {
+              var card = reviewCards[i];
+              var review = {};
+              
+              // Title
+              var titleEl = card.querySelector('[data-testid="review-title"]');
+              review.title = titleEl?.textContent?.trim() || '';
+              
+              // Score - extract number from "Scored 10 10"
+              var scoreEl = card.querySelector('[data-testid="review-score"]');
+              var scoreText = scoreEl?.textContent?.trim() || '';
+              var scoreMatch = scoreText.match(/Scored\\s+([\\d.]+)/);
+              review.rating = scoreMatch ? parseFloat(scoreMatch[1]) : null;
+              
+              // Date - remove "Reviewed: " prefix
+              var dateEl = card.querySelector('[data-testid="review-date"]');
+              var dateText = dateEl?.textContent?.trim() || '';
+              review.date = dateText.replace(/^Reviewed:\\s*/i, '');
+              
+              // Traveler type
+              var typeEl = card.querySelector('[data-testid="review-traveler-type"]');
+              review.travelerType = typeEl?.textContent?.trim() || '';
+              
+              // Stay date
+              var stayDateEl = card.querySelector('[data-testid="review-stay-date"]');
+              review.stayDate = stayDateEl?.textContent?.trim() || '';
+              
+              // Room name
+              var roomEl = card.querySelector('[data-testid="review-room-name"]');
+              review.roomType = roomEl?.textContent?.trim() || '';
+              
+              // Num nights
+              var nightsEl = card.querySelector('[data-testid="review-num-nights"]');
+              review.nightsStayed = nightsEl?.textContent?.trim()?.replace(/·/g, '').trim() || '';
+              
+              // Positive
+              var positiveEl = card.querySelector('[data-testid="review-positive-text"]');
+              review.positive = positiveEl?.textContent?.trim() || '';
+              
+              // Negative
+              var negativeEl = card.querySelector('[data-testid="review-negative-text"]');
+              review.negative = negativeEl?.textContent?.trim() || '';
+              
+              // Avatar/country - extract country from text like "JJohn United Kingdom"
+              var avatarEl = card.querySelector('[data-testid="review-avatar"]');
+              var avatarText = avatarEl?.textContent?.trim() || '';
+              // Try to extract country (usually after the name, common patterns)
+              var countryPatterns = [
+                /(?:United Kingdom|United States|Ireland|France|Germany|Spain|Italy|Netherlands|Belgium|Switzerland|Australia|Canada|Sweden|Norway|Denmark|Japan|China|Brazil|Mexico|India|South Korea|Russia|Poland|Austria|Portugal|Greece|Turkey|Czech Republic|Hungary|Romania|Argentina|Chile|Colombia|Thailand|Singapore|Malaysia|Indonesia|Philippines|Vietnam|New Zealand|Finland|Israel|South Africa|Egypt|United Arab Emirates|Saudi Arabia)$/i
+              ];
+              review.country = '';
+              for (var p = 0; p < countryPatterns.length; p++) {
+                var match = avatarText.match(countryPatterns[p]);
+                if (match) {
+                  review.country = match[0];
+                  break;
+                }
+              }
+              // Fallback: take last two words if no country matched
+              if (!review.country && avatarText) {
+                var words = avatarText.split(/\\s+/);
+                if (words.length >= 2) {
+                  review.country = words.slice(-2).join(' ');
+                } else if (words.length === 1) {
+                  review.country = words[0];
+                }
+              }
+              
+              reviews.push(review);
+            }
+            
+            return reviews;
+          })()
+        `);
+            // Build rating breakdown with proper null handling
+            const ratingBreakdown = {
+                staff: mainPageData.breakdown.staff ?? null,
+                facilities: mainPageData.breakdown.facilities ?? null,
+                cleanliness: mainPageData.breakdown.cleanliness ?? null,
+                comfort: mainPageData.breakdown.comfort ?? null,
+                valueForMoney: mainPageData.breakdown.valueForMoney ?? null,
+                location: mainPageData.breakdown.location ?? null,
+                freeWifi: mainPageData.breakdown.freeWifi ?? null,
+            };
+            return {
+                hotelName: mainPageData.hotelName,
+                overallRating: mainPageData.overallRating,
+                totalReviews: mainPageData.totalReviews,
+                ratingBreakdown,
+                reviews: reviews.slice(0, limit),
+                url: cleanUrl,
+            };
+        }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
+            console.error(`Get reviews attempt ${attempt} failed: ${error.message}. Retrying in ${Math.round(delayMs / 1000)}s...`);
+        });
+    }
 }

package/dist/index.js

@@ -126,6 +126,19 @@ const HotelDetailsSchema = z.object({
 const CompareHotelsSchema = z.object({
     urls: z.array(z.string()).min(2).max(3).describe("Array of 2-3 Booking.com hotel URLs to compare"),
 });
+const CheckAvailabilitySchema = z.object({
+    hotelUrl: z.string().describe("Booking.com hotel URL to check availability for"),
+    checkIn: z.string().describe("Check-in date (YYYY-MM-DD)"),
+    checkOut: z.string().describe("Check-out date (YYYY-MM-DD)"),
+    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)"),
+});
+const GetReviewsSchema = z.object({
+    hotelUrl: z.string().describe("Booking.com hotel URL to get reviews for"),
+    limit: z.number().min(1).max(50).optional().describe("Number of reviews to fetch (default: 10, max: 50)"),
+    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"),
+});
 // Global browser instance (reuse for efficiency)
 let browser = null;
 async function getBrowser() {
@@ -303,10 +316,132 @@ function formatHotelComparison(hotels) {
     });
     return lines.join("\n");
 }
+function formatAvailabilityResult(result) {
+    const lines = [];
+    lines.push("=".repeat(60));
+    lines.push("AVAILABILITY CHECK");
+    lines.push("=".repeat(60));
+    lines.push("");
+    lines.push(`Hotel: ${result.hotelName}`);
+    lines.push(`Dates: ${result.checkIn} to ${result.checkOut}`);
+    lines.push(`Guests: ${result.guests} | Rooms: ${result.rooms}`);
+    lines.push("");
+    if (!result.available) {
+        lines.push("STATUS: NOT AVAILABLE");
+        lines.push(result.message);
+    }
+    else {
+        lines.push(`STATUS: AVAILABLE - ${result.message}`);
+        lines.push("");
+        lines.push("--- ROOM OPTIONS ---");
+        lines.push("");
+        result.roomOptions.forEach((room, i) => {
+            lines.push(`${i + 1}. ${room.name}`);
+            if (room.priceDisplay) {
+                lines.push(`   Price: ${room.priceDisplay}`);
+            }
+            if (room.sleeps) {
+                lines.push(`   Sleeps: ${room.sleeps}`);
+            }
+            if (room.bedType) {
+                lines.push(`   Bed: ${room.bedType}`);
+            }
+            if (room.cancellation) {
+                lines.push(`   Cancellation: ${room.cancellation}`);
+            }
+            if (room.breakfast) {
+                lines.push(`   Meals: ${room.breakfast}`);
+            }
+            if (room.features.length > 0) {
+                lines.push(`   Features: ${room.features.join(", ")}`);
+            }
+            lines.push("");
+        });
+        if (result.lowestPrice) {
+            lines.push("--- SUMMARY ---");
+            lines.push(`Lowest price: ${result.lowestPriceDisplay}`);
+        }
+    }
+    lines.push("");
+    lines.push("=".repeat(60));
+    lines.push(`Book at: ${result.url.split("?")[0]}`);
+    return lines.join("\n");
+}
+function formatReviewsResult(result) {
+    const lines = [];
+    lines.push("=".repeat(60));
+    lines.push(`REVIEWS: ${result.hotelName}`);
+    lines.push("=".repeat(60));
+    lines.push("");
+    // Overall rating
+    if (result.overallRating) {
+        lines.push(`Overall Rating: ${result.overallRating}/10 (${result.totalReviews} reviews)`);
+    }
+    else {
+        lines.push(`Total Reviews: ${result.totalReviews}`);
+    }
+    lines.push("");
+    // Rating breakdown
+    const breakdown = result.ratingBreakdown;
+    const categories = [
+        { label: "Staff", value: breakdown.staff },
+        { label: "Facilities", value: breakdown.facilities },
+        { label: "Cleanliness", value: breakdown.cleanliness },
+        { label: "Comfort", value: breakdown.comfort },
+        { label: "Value for Money", value: breakdown.valueForMoney },
+        { label: "Location", value: breakdown.location },
+        { label: "Free WiFi", value: breakdown.freeWifi },
+    ];
+    const validCategories = categories.filter(c => c.value !== null);
+    if (validCategories.length > 0) {
+        lines.push("--- RATING BREAKDOWN ---");
+        validCategories.forEach(cat => {
+            lines.push(`${cat.label}: ${cat.value}`);
+        });
+        lines.push("");
+    }
+    // Individual reviews
+    if (result.reviews.length > 0) {
+        lines.push(`--- REVIEWS (${result.reviews.length}) ---`);
+        lines.push("");
+        result.reviews.forEach((review, index) => {
+            lines.push(`[${index + 1}] ${review.title || "Review"}`);
+            if (review.rating !== null) {
+                lines.push(`   Score: ${review.rating}/10`);
+            }
+            if (review.country) {
+                lines.push(`   Reviewer: ${review.country}`);
+            }
+            if (review.travelerType) {
+                lines.push(`   Traveler Type: ${review.travelerType}`);
+            }
+            if (review.roomType) {
+                lines.push(`   Room: ${review.roomType}`);
+            }
+            if (review.stayDate || review.nightsStayed) {
+                const stayInfo = [review.stayDate, review.nightsStayed].filter(Boolean).join(" - ");
+                lines.push(`   Stayed: ${stayInfo}`);
+            }
+            if (review.date) {
+                lines.push(`   Reviewed: ${review.date}`);
+            }
+            if (review.positive) {
+                lines.push(`   + ${review.positive}`);
+            }
+            if (review.negative) {
+                lines.push(`   - ${review.negative}`);
+            }
+            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.4.0",
+    version: "1.6.0",
 }, {
     capabilities: {
         tools: {},
@@ -494,6 +629,35 @@ Results are scored and ranked by how well they match the criteria.`,
                     required: ["urls"],
                 },
             },
+            {
+                name: "check_availability",
+                description: "Check room availability and prices for a specific hotel on given dates. Returns available room types, prices, and booking details.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        hotelUrl: { type: "string", description: "Booking.com hotel URL to check" },
+                        checkIn: { type: "string", description: "Check-in date (YYYY-MM-DD)" },
+                        checkOut: { type: "string", description: "Check-out date (YYYY-MM-DD)" },
+                        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 },
+                    },
+                    required: ["hotelUrl", "checkIn", "checkOut"],
+                },
+            },
+            {
+                name: "get_reviews",
+                description: "Get guest reviews for a specific hotel. Returns overall rating, rating breakdown by category (staff, facilities, cleanliness, comfort, value, location, WiFi), and individual reviews with positive/negative comments, reviewer info, and stay details.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        hotelUrl: { type: "string", description: "Booking.com hotel URL to get reviews for" },
+                        limit: { type: "number", description: "Number of reviews to fetch (default: 10, max: 50)", minimum: 1, maximum: 50 },
+                        sortBy: { type: "string", description: "Sort reviews by", enum: ["recent", "highest", "lowest"] },
+                        filterBy: { type: "string", description: "Filter by traveler type", enum: ["couples", "families", "solo", "business", "groups"] },
+                    },
+                    required: ["hotelUrl"],
+                },
+            },
         ],
     };
 });
@@ -649,6 +813,38 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "check_availability": {
+                const parsed = CheckAvailabilitySchema.parse(args);
+                const result = await b.checkAvailability({
+                    hotelUrl: parsed.hotelUrl,
+                    checkIn: parsed.checkIn,
+                    checkOut: parsed.checkOut,
+                    guests: parsed.guests,
+                    rooms: parsed.rooms,
+                });
+                const formatted = formatAvailabilityResult(result);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatted,
+                        },
+                    ],
+                };
+            }
+            case "get_reviews": {
+                const parsed = GetReviewsSchema.parse(args);
+                const result = await b.getReviews(parsed.hotelUrl, parsed.limit, parsed.sortBy, parsed.filterBy);
+                const formatted = formatReviewsResult(result);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: formatted,
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -717,7 +913,7 @@ process.on("SIGTERM", async () => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("HotelZero v1.4.0 running on stdio");
+    console.error("HotelZero v1.6.0 running on stdio");
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/package.json

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