hotelzero 1.11.0 → 1.12.0

package/README.md

@@ -81,6 +81,36 @@ Logs are JSON-formatted for easy parsing:
 {"level":"info","time":"2026-02-15T12:00:02.000Z","service":"hotelzero","module":"browser","destination":"Paris","msg":"Starting hotel search"}
 ```
 
+## Session Persistence
+
+HotelZero automatically saves browser session data (cookies, localStorage) to reduce bot detection and avoid repeated CAPTCHA challenges.
+
+### How It Works
+
+- Sessions are automatically saved after each successful request
+- On startup, the previous session is loaded if available
+- Default session location: `~/.hotelzero/session.json`
+
+### Custom Session Path
+
+Use `HOTELZERO_SESSION_PATH` to specify a custom location:
+
+```bash
+# Custom session file location
+HOTELZERO_SESSION_PATH=/path/to/session.json npx hotelzero
+
+# Disable session persistence (use empty string)
+HOTELZERO_SESSION_PATH="" npx hotelzero
+```
+
+### Clearing Sessions
+
+If you experience issues, you can delete the session file:
+
+```bash
+rm ~/.hotelzero/session.json
+```
+
 ## Quick Start
 
 ### Run as MCP Server

package/dist/browser.d.ts

@@ -227,12 +227,35 @@ export interface PriceCalendarResult {
 }
 export declare class HotelBrowser {
     private browser;
+    private context;
     private page;
     private lastRequestTime;
     private minRequestIntervalMs;
     private proxyConfig;
     private currentUserAgent;
+    private sessionPath;
     init(headless?: boolean, proxy?: ProxyConfig): Promise<void>;
+    /**
+     * Save the current session (cookies, localStorage) to disk
+     * Call this after successful requests to persist session state
+     */
+    saveSession(): Promise<boolean>;
+    /**
+     * Check if session persistence is enabled
+     */
+    hasSessionPath(): boolean;
+    /**
+     * Get the current session file path
+     */
+    getSessionPath(): string | null;
+    /**
+     * Check if a saved session file exists
+     */
+    static hasExistingSession(): boolean;
+    /**
+     * Clear the saved session file
+     */
+    static clearSession(): boolean;
     /**
      * Check if a proxy is configured
      */

package/dist/browser.js

@@ -1,5 +1,23 @@
 import { chromium } from "playwright";
 import { browserLogger as logger } from "./logger.js";
+import * as fs from "fs";
+import * as path from "path";
+// Session/cookie persistence configuration
+const SESSION_PATH = process.env.HOTELZERO_SESSION_PATH || "";
+/**
+ * Get the default session file path
+ * Uses ~/.hotelzero/session.json if no custom path is specified
+ */
+function getDefaultSessionPath() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(homeDir, ".hotelzero", "session.json");
+}
+/**
+ * Get the session file path (custom or default)
+ */
+function getSessionPath() {
+    return SESSION_PATH || getDefaultSessionPath();
+}
 // Custom error types for better error handling
 export class HotelSearchError extends Error {
     code;
@@ -259,17 +277,28 @@ const FILTER_CODES = {
 };
 export class HotelBrowser {
     browser = null;
+    context = null;
     page = null;
     lastRequestTime = 0;
     minRequestIntervalMs = 2000; // Minimum 2 seconds between requests
     proxyConfig = null;
     currentUserAgent = "";
+    sessionPath = "";
     async init(headless = true, proxy) {
         // Store proxy config for reference
         this.proxyConfig = proxy || null;
         // Select a random user agent for this session
         this.currentUserAgent = getRandomUserAgent();
-        logger.debug({ headless, hasProxy: !!proxy, userAgent: this.currentUserAgent }, "Initializing browser");
+        // Determine session path
+        this.sessionPath = getSessionPath();
+        const hasExistingSession = this.sessionPath && fs.existsSync(this.sessionPath);
+        logger.debug({
+            headless,
+            hasProxy: !!proxy,
+            userAgent: this.currentUserAgent,
+            sessionPath: this.sessionPath || "(disabled)",
+            hasExistingSession
+        }, "Initializing browser");
         // Build launch options
         const launchOptions = {
             headless,
@@ -284,12 +313,90 @@ export class HotelBrowser {
             };
         }
         this.browser = await chromium.launch(launchOptions);
-        const context = await this.browser.newContext({
+        // Build context options
+        const contextOptions = {
             userAgent: this.currentUserAgent,
             viewport: { width: 1280, height: 900 },
-        });
-        this.page = await context.newPage();
-        logger.info({ hasProxy: !!proxy }, "Browser initialized successfully");
+        };
+        // Load existing session state if available
+        if (hasExistingSession) {
+            try {
+                contextOptions.storageState = this.sessionPath;
+                logger.debug({ sessionPath: this.sessionPath }, "Loading existing session");
+            }
+            catch (error) {
+                logger.warn({ error, sessionPath: this.sessionPath }, "Failed to load session, starting fresh");
+            }
+        }
+        this.context = await this.browser.newContext(contextOptions);
+        this.page = await this.context.newPage();
+        logger.info({
+            hasProxy: !!proxy,
+            sessionLoaded: hasExistingSession
+        }, "Browser initialized successfully");
+    }
+    /**
+     * Save the current session (cookies, localStorage) to disk
+     * Call this after successful requests to persist session state
+     */
+    async saveSession() {
+        if (!this.context || !this.sessionPath) {
+            logger.debug("Cannot save session: no context or session path disabled");
+            return false;
+        }
+        try {
+            // Ensure directory exists
+            const sessionDir = path.dirname(this.sessionPath);
+            if (!fs.existsSync(sessionDir)) {
+                fs.mkdirSync(sessionDir, { recursive: true });
+                logger.debug({ sessionDir }, "Created session directory");
+            }
+            // Save storage state (cookies + localStorage)
+            await this.context.storageState({ path: this.sessionPath });
+            logger.debug({ sessionPath: this.sessionPath }, "Session saved successfully");
+            return true;
+        }
+        catch (error) {
+            logger.warn({ error, sessionPath: this.sessionPath }, "Failed to save session");
+            return false;
+        }
+    }
+    /**
+     * Check if session persistence is enabled
+     */
+    hasSessionPath() {
+        return !!this.sessionPath;
+    }
+    /**
+     * Get the current session file path
+     */
+    getSessionPath() {
+        return this.sessionPath || null;
+    }
+    /**
+     * Check if a saved session file exists
+     */
+    static hasExistingSession() {
+        const sessionPath = getSessionPath();
+        return !!sessionPath && fs.existsSync(sessionPath);
+    }
+    /**
+     * Clear the saved session file
+     */
+    static clearSession() {
+        const sessionPath = getSessionPath();
+        if (sessionPath && fs.existsSync(sessionPath)) {
+            try {
+                fs.unlinkSync(sessionPath);
+                logger.info({ sessionPath }, "Session cleared");
+                return true;
+            }
+            catch (error) {
+                logger.warn({ error, sessionPath }, "Failed to clear session");
+                return false;
+            }
+        }
+        return false;
     }
     /**
      * Check if a proxy is configured
@@ -319,6 +426,7 @@ export class HotelBrowser {
         if (this.browser) {
             await this.browser.close();
             this.browser = null;
+            this.context = null;
             this.page = null;
             logger.debug("Browser closed");
         }
@@ -665,9 +773,13 @@ export class HotelBrowser {
             if (filters) {
                 const scored = this.scoreAndFilterHotels(hotels, filters);
                 logger.info({ resultCount: scored.length }, "Search completed with filters");
+                // Auto-save session after successful search
+                await this.saveSession();
                 return scored;
             }
             logger.info({ resultCount: hotels.length }, "Search completed");
+            // Auto-save session after successful search
+            await this.saveSession();
             return hotels;
         }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
             logger.warn({ attempt, error: error.message, retryInMs: delayMs }, "Search attempt failed, retrying");
@@ -1545,7 +1657,7 @@ export class HotelBrowser {
             else {
                 message = `${result.roomOptions.length} room types available${lowestPrice ? ` from ${lowestPriceRoom?.priceDisplay || '$' + lowestPrice}` : ''}.`;
             }
-            return {
+            const availabilityResult = {
                 available,
                 hotelName: result.hotelName,
                 checkIn,
@@ -1558,6 +1670,9 @@ export class HotelBrowser {
                 message,
                 url: urlWithDates,
             };
+            // Auto-save session after successful availability check
+            await this.saveSession();
+            return availabilityResult;
         }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
             logger.warn({ attempt, error: error.message, retryInMs: delayMs }, "Check availability attempt failed, retrying");
         });
@@ -1814,7 +1929,7 @@ export class HotelBrowser {
                 location: mainPageData.breakdown.location ?? null,
                 freeWifi: mainPageData.breakdown.freeWifi ?? null,
             };
-            return {
+            const reviewsResult = {
                 hotelName: mainPageData.hotelName,
                 overallRating: mainPageData.overallRating,
                 totalReviews: mainPageData.totalReviews,
@@ -1822,6 +1937,9 @@ export class HotelBrowser {
                 reviews: reviews.slice(0, limit),
                 url: cleanUrl,
             };
+            // Auto-save session after successful reviews fetch
+            await this.saveSession();
+            return reviewsResult;
         }, DEFAULT_RETRY_CONFIG, (attempt, error, delayMs) => {
             logger.warn({ attempt, error: error.message, retryInMs: delayMs }, "Get reviews attempt failed, retrying");
         });
@@ -1991,7 +2109,7 @@ export class HotelBrowser {
         // Calculate end date
         const endDate = new Date(start);
         endDate.setDate(endDate.getDate() + actualNights - 1);
-        return {
+        const priceCalendarResult = {
             hotelName,
             startDate,
             endDate: endDate.toISOString().split("T")[0],
@@ -2005,5 +2123,8 @@ export class HotelBrowser {
             averagePrice,
             url: cleanUrl,
         };
+        // Auto-save session after successful price calendar fetch
+        await this.saveSession();
+        return priceCalendarResult;
     }
 }

package/dist/index.js

@@ -547,7 +547,7 @@ function formatPriceCalendarResult(result) {
 // Create MCP server
 const server = new Server({
     name: "hotelzero",
-    version: "1.11.0",
+    version: "1.12.0",
 }, {
     capabilities: {
         tools: {},

package/package.json

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