@jshookmcp/jshook 0.1.5 → 0.1.6

package/dist/modules/browser/BrowserModeManager.js

@@ -7,6 +7,8 @@ export class BrowserModeManager {
     browser = null;
     currentPage = null;
     isHeadless = true;
+    isClosing = false;
+    launchPromise;
     config;
     captchaDetector;
     launchOptions;
@@ -24,6 +26,27 @@ export class BrowserModeManager {
         this.launchOptions = launchOptions;
     }
     async launch() {
+        if (this.browser?.isConnected()) {
+            return this.browser;
+        }
+        if (this.isClosing) {
+            throw new Error('Cannot launch browser while closing');
+        }
+        if (this.launchPromise) {
+            return this.launchPromise;
+        }
+        const launchPromise = this.doLaunch();
+        this.launchPromise = launchPromise;
+        try {
+            return await launchPromise;
+        }
+        finally {
+            if (this.launchPromise === launchPromise) {
+                this.launchPromise = undefined;
+            }
+        }
+    }
+    async doLaunch() {
         const headlessMode = this.isHeadless;
         const executablePath = this.resolveExecutablePath();
         logger.info(`Launching browser (${headlessMode ? 'headless' : 'headed'} mode)...`);
@@ -43,7 +66,14 @@ export class BrowserModeManager {
         if (executablePath) {
             options.executablePath = executablePath;
         }
-        this.browser = await puppeteer.launch(options);
+        const browser = await puppeteer.launch(options);
+        if (this.isClosing) {
+            await browser.close().catch(error => {
+                logger.warn('Failed to close browser launched during shutdown', error);
+            });
+            throw new Error('Browser launch aborted because close was requested');
+        }
+        this.browser = browser;
         logger.info('Browser launched successfully');
         return this.browser;
     }
@@ -64,10 +94,8 @@ export class BrowserModeManager {
         return undefined;
     }
     async newPage() {
-        if (!this.browser) {
-            await this.launch();
-        }
-        const page = await this.browser.newPage();
+        const browser = this.browser?.isConnected() ? this.browser : await this.launch();
+        const page = await browser.newPage();
         this.currentPage = page;
         await this.injectAntiDetectionScripts(page);
         if (this.sessionData.cookies && this.sessionData.cookies.length > 0) {
@@ -75,6 +103,20 @@ export class BrowserModeManager {
         }
         return page;
     }
+    async finalizeClose() {
+        try {
+            const browser = this.browser;
+            this.browser = null;
+            this.currentPage = null;
+            if (browser) {
+                await browser.close();
+                logger.info('Browser closed');
+            }
+        }
+        finally {
+            this.isClosing = false;
+        }
+    }
     async goto(url, page) {
         const targetPage = page || this.currentPage;
         if (!targetPage) {
@@ -111,6 +153,10 @@ export class BrowserModeManager {
         await this.launch();
         const newPage = await this.newPage();
         await newPage.goto(url, { waitUntil: 'networkidle2' });
+        await this.restoreSessionData(newPage);
+        if (this.sessionData.localStorage || this.sessionData.sessionStorage) {
+            await newPage.reload({ waitUntil: 'networkidle2' });
+        }
         this.showCaptchaPrompt(captchaInfo);
         const completed = await this.captchaDetector.waitForCompletion(newPage, this.config.captchaTimeout);
         if (completed) {
@@ -147,7 +193,10 @@ export class BrowserModeManager {
         }
     }
     async saveSessionData(page) {
+        this.sessionData = {};
         try {
+            const url = page.url();
+            this.sessionData.origin = url !== 'about:blank' ? new URL(url).origin : undefined;
             this.sessionData.cookies = await page.cookies();
             const storageData = await page.evaluate(() => {
                 const local = {};
@@ -174,6 +223,37 @@ export class BrowserModeManager {
             logger.error('Failed to capture session data before mode switch', error);
         }
     }
+    async restoreSessionData(page) {
+        try {
+            const currentUrl = page.url();
+            const currentOrigin = currentUrl !== 'about:blank' ? new URL(currentUrl).origin : undefined;
+            if (this.sessionData.origin && currentOrigin && this.sessionData.origin !== currentOrigin) {
+                logger.warn(`Origin mismatch: session data from ${this.sessionData.origin} cannot be restored to ${currentOrigin}. ` +
+                    'This prevents cross-origin data leakage.');
+                return;
+            }
+            if (this.sessionData.localStorage || this.sessionData.sessionStorage) {
+                await page.evaluate((data) => {
+                    const restoreStorage = (storage, items) => {
+                        if (items) {
+                            for (const [key, value] of Object.entries(items)) {
+                                storage.setItem(key, value);
+                            }
+                        }
+                    };
+                    restoreStorage(localStorage, data.local);
+                    restoreStorage(sessionStorage, data.session);
+                }, {
+                    local: this.sessionData.localStorage,
+                    session: this.sessionData.sessionStorage
+                });
+                logger.info('Session storage data restored');
+            }
+        }
+        catch (error) {
+            logger.error('Failed to restore session storage data', error);
+        }
+    }
     async injectAntiDetectionScripts(page) {
         await page.evaluateOnNewDocument(() => {
             Object.defineProperty(navigator, 'webdriver', {
@@ -265,12 +345,18 @@ export class BrowserModeManager {
         logger.info('Injected anti-detection scripts');
     }
     async close() {
-        if (this.browser) {
-            await this.browser.close();
-            this.browser = null;
-            this.currentPage = null;
-            logger.info('Browser closed');
+        this.sessionData = {};
+        this.isClosing = true;
+        const pendingLaunch = this.launchPromise;
+        if (pendingLaunch) {
+            void pendingLaunch
+                .catch(() => undefined)
+                .finally(() => {
+                void this.finalizeClose();
+            });
+            return;
         }
+        await this.finalizeClose();
     }
     getBrowser() {
         return this.browser;

package/dist/modules/browser/CamoufoxBrowserManager.d.ts

@@ -30,11 +30,15 @@ export declare class CamoufoxBrowserManager {
     private browser;
     private browserServer;
     private config;
+    private isClosing;
+    private launchPromise?;
     constructor(config?: CamoufoxBrowserConfig);
     launch(): Promise<CamoufoxBrowserLike>;
+    private doLaunch;
     newPage(): Promise<CamoufoxPageLike>;
     goto(url: string, page?: CamoufoxPageLike): Promise<CamoufoxPageLike>;
     close(): Promise<void>;
+    private finalizeClose;
     launchAsServer(port?: number, ws_path?: string): Promise<string>;
     connectToServer(wsEndpoint: string): Promise<CamoufoxBrowserLike>;
     closeBrowserServer(): Promise<void>;

package/dist/modules/browser/CamoufoxBrowserManager.js

@@ -4,6 +4,8 @@ export class CamoufoxBrowserManager {
     browser = null;
     browserServer = null;
     config;
+    isClosing = false;
+    launchPromise;
     constructor(config = {}) {
         this.config = {
             os: config.os ?? 'windows',
@@ -16,6 +18,29 @@ export class CamoufoxBrowserManager {
         };
     }
     async launch() {
+        if (this.browser?.isConnected()) {
+            return this.browser;
+        }
+        if (this.isClosing) {
+            throw new Error('Cannot launch browser while closing');
+        }
+        if (this.launchPromise) {
+            return this.launchPromise;
+        }
+        this.launchPromise = this.doLaunch();
+        try {
+            return await this.launchPromise;
+        }
+        finally {
+            this.launchPromise = undefined;
+        }
+    }
+    async doLaunch() {
+        if (this.browser) {
+            logger.info('Closing existing Camoufox browser before relaunch');
+            await this.browser.close().catch(err => logger.warn('Failed to close previous browser:', err));
+            this.browser = null;
+        }
         logger.info(`Launching Camoufox (Firefox) [os=${this.config.os}, headless=${this.config.headless}]...`);
         let Camoufox;
         try {
@@ -33,6 +58,13 @@ export class CamoufoxBrowserManager {
             block_images: this.config.blockImages,
             block_webrtc: this.config.blockWebrtc,
         }));
+        if (this.isClosing) {
+            await this.browser.close().catch(error => {
+                logger.warn('Failed to close Camoufox browser launched during shutdown:', error);
+            });
+            this.browser = null;
+            throw new Error('Camoufox launch aborted because close was requested');
+        }
         logger.info('Camoufox browser launched');
         return this.browser;
     }
@@ -51,10 +83,29 @@ export class CamoufoxBrowserManager {
         return targetPage;
     }
     async close() {
-        if (this.browser) {
-            await this.browser.close();
+        this.isClosing = true;
+        const pendingLaunch = this.launchPromise;
+        if (pendingLaunch) {
+            void pendingLaunch
+                .catch(() => undefined)
+                .finally(() => {
+                void this.finalizeClose();
+            });
+            return;
+        }
+        await this.finalizeClose();
+    }
+    async finalizeClose() {
+        try {
+            const browser = this.browser;
             this.browser = null;
-            logger.info('Camoufox browser closed');
+            if (browser) {
+                await browser.close();
+                logger.info('Camoufox browser closed');
+            }
+        }
+        finally {
+            this.isClosing = false;
         }
     }
     async launchAsServer(port, ws_path) {
@@ -77,6 +128,11 @@ export class CamoufoxBrowserManager {
             port,
             ws_path,
         };
+        if (this.browserServer) {
+            logger.info('Closing existing Camoufox server before relaunch');
+            await this.browserServer.close().catch(err => logger.warn('Failed to close previous server:', err));
+            this.browserServer = null;
+        }
         this.browserServer = await launchServer(serverOptions);
         const endpoint = this.browserServer.wsEndpoint();
         logger.info(`Camoufox server listening on: ${endpoint}`);
@@ -84,6 +140,11 @@ export class CamoufoxBrowserManager {
     }
     async connectToServer(wsEndpoint) {
         logger.info(`Connecting to Camoufox server: ${wsEndpoint}`);
+        if (this.browser) {
+            logger.info('Disconnecting existing browser before new connection');
+            await this.browser.close().catch(err => logger.warn('Failed to close previous browser:', err));
+            this.browser = null;
+        }
         const playwrightModule = await import('playwright-core');
         const firefox = playwrightModule.firefox;
         this.browser = (await firefox.connect(wsEndpoint));

package/dist/modules/browser/TabRegistry.js

@@ -113,7 +113,8 @@ export class TabRegistry {
         return null;
     }
     setCurrentPageId(pageId) {
-        if (!this.tabsById.has(pageId))
+        const entry = this.tabsById.get(pageId);
+        if (!entry || entry.stale)
             return false;
         this.currentPageId = pageId;
         return true;
@@ -167,7 +168,7 @@ export class TabRegistry {
             url: current?.meta.url ?? null,
             title: current?.meta.title ?? null,
             tabIndex: current?.meta.index ?? null,
-            pageId: this.currentPageId,
+            pageId: current ? this.currentPageId : null,
         };
     }
     listTabs() {

package/dist/modules/browser/UnifiedBrowserManager.d.ts

@@ -46,10 +46,15 @@ export declare class UnifiedBrowserManager implements IBrowserManager {
     private camoufoxManager;
     private browserDiscovery;
     private activePage;
+    private chromeLaunchPromise?;
+    private camoufoxLaunchPromise?;
+    private isClosing;
     constructor(config?: UnifiedBrowserConfig);
     launch(): Promise<PuppeteerBrowser | CamoufoxBrowserLike>;
     private launchChrome;
+    private doLaunchChrome;
     private launchCamoufox;
+    private doLaunchCamoufox;
     connect(wsEndpoint: string): Promise<PuppeteerBrowser | CamoufoxBrowserLike>;
     private connectChrome;
     private connectCamoufox;

package/dist/modules/browser/UnifiedBrowserManager.js

@@ -9,6 +9,9 @@ export class UnifiedBrowserManager {
     camoufoxManager = null;
     browserDiscovery;
     activePage = null;
+    chromeLaunchPromise;
+    camoufoxLaunchPromise;
+    isClosing = false;
     constructor(config = {}) {
         this.config = config;
         this.driver = config.driver ?? 'chrome';
@@ -21,6 +24,25 @@ export class UnifiedBrowserManager {
         return this.launchChrome();
     }
     async launchChrome() {
+        if (this.isClosing) {
+            throw new Error('Cannot launch browser while closing');
+        }
+        const existingBrowser = this.chromeManager?.getBrowser();
+        if (existingBrowser?.isConnected()) {
+            return existingBrowser;
+        }
+        if (this.chromeLaunchPromise) {
+            return this.chromeLaunchPromise;
+        }
+        this.chromeLaunchPromise = this.doLaunchChrome();
+        try {
+            return await this.chromeLaunchPromise;
+        }
+        finally {
+            this.chromeLaunchPromise = undefined;
+        }
+    }
+    async doLaunchChrome() {
         logger.info(`Launching Chrome [headless=${this.config.headless ?? true}]...`);
         const modeConfig = {
             autoDetectCaptcha: this.config.autoDetectCaptcha,
@@ -46,6 +68,25 @@ export class UnifiedBrowserManager {
         return browser;
     }
     async launchCamoufox() {
+        if (this.isClosing) {
+            throw new Error('Cannot launch browser while closing');
+        }
+        const existingBrowser = this.camoufoxManager?.getBrowser();
+        if (existingBrowser?.isConnected()) {
+            return existingBrowser;
+        }
+        if (this.camoufoxLaunchPromise) {
+            return this.camoufoxLaunchPromise;
+        }
+        this.camoufoxLaunchPromise = this.doLaunchCamoufox();
+        try {
+            return await this.camoufoxLaunchPromise;
+        }
+        finally {
+            this.camoufoxLaunchPromise = undefined;
+        }
+    }
+    async doLaunchCamoufox() {
         const headless = this.normalizeCamoufoxHeadless();
         logger.info(`Launching Camoufox (Firefox) [os=${this.config.os ?? 'windows'}, headless=${headless}]...`);
         const camoufoxConfig = {
@@ -114,18 +155,30 @@ export class UnifiedBrowserManager {
         return this.chromeManager.goto(url, targetPage);
     }
     async close() {
-        if (this.driver === 'camoufox' && this.camoufoxManager) {
-            await this.camoufoxManager.close();
+        this.isClosing = true;
+        try {
+            const camoufoxManager = this.camoufoxManager;
+            const chromeManager = this.chromeManager;
             this.camoufoxManager = null;
-            this.activePage = null;
-            logger.info('Camoufox browser closed');
-            return;
-        }
-        if (this.chromeManager) {
-            await this.chromeManager.close();
             this.chromeManager = null;
+            this.chromeLaunchPromise = undefined;
+            this.camoufoxLaunchPromise = undefined;
             this.activePage = null;
-            logger.info('Chrome browser closed');
+            const closeTasks = [];
+            if (camoufoxManager) {
+                closeTasks.push(camoufoxManager.close().then(() => {
+                    logger.info('Camoufox browser closed');
+                }));
+            }
+            if (chromeManager) {
+                closeTasks.push(chromeManager.close().then(() => {
+                    logger.info('Chrome browser closed');
+                }));
+            }
+            await Promise.all(closeTasks);
+        }
+        finally {
+            this.isClosing = false;
         }
     }
     getBrowser() {