@jshookmcp/jshook 0.1.5 → 0.1.7

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() {

package/dist/modules/debugger/DebuggerSessionManager.d.ts

@@ -7,7 +7,11 @@ type SavedDebuggerSessionSummary = {
 };
 export declare class DebuggerSessionManager {
     private debuggerManager;
+    private readonly SESSION_IMPORT_BATCH_SIZE;
+    private readonly SESSION_FILE_READ_BATCH_SIZE;
     constructor(debuggerManager: DebuggerManager);
+    private processInBatches;
+    private readSessionFile;
     private validateFilePath;
     exportSession(metadata?: DebuggerSession['metadata']): DebuggerSession;
     saveSession(filePath?: string, metadata?: DebuggerSession['metadata']): Promise<string>;

package/dist/modules/debugger/DebuggerSessionManager.js

@@ -4,9 +4,20 @@ import * as path from 'path';
 import { logger } from '../../utils/logger.js';
 export class DebuggerSessionManager {
     debuggerManager;
+    SESSION_IMPORT_BATCH_SIZE = 8;
+    SESSION_FILE_READ_BATCH_SIZE = 8;
     constructor(debuggerManager) {
         this.debuggerManager = debuggerManager;
     }
+    async processInBatches(items, batchSize, worker) {
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await Promise.all(batch.map((item) => worker(item)));
+        }
+    }
+    async readSessionFile(filePath) {
+        return fs.readFile(filePath, 'utf-8');
+    }
     async validateFilePath(filePath) {
         const resolved = path.resolve(filePath);
         const cwd = await fs.realpath(process.cwd());
@@ -70,7 +81,7 @@ export class DebuggerSessionManager {
     }
     async loadSessionFromFile(filePath) {
         const resolvedPath = await this.validateFilePath(filePath);
-        const content = await fs.readFile(resolvedPath, 'utf-8');
+        const content = await this.readSessionFile(resolvedPath);
         const session = JSON.parse(content);
         await this.importSession(session);
         logger.info(`Session loaded from ${resolvedPath}`, {
@@ -93,7 +104,7 @@ export class DebuggerSessionManager {
         await this.debuggerManager.clearAllBreakpoints();
         let successCount = 0;
         let failCount = 0;
-        for (const bp of session.breakpoints) {
+        await this.processInBatches(session.breakpoints, this.SESSION_IMPORT_BATCH_SIZE, async (bp) => {
             try {
                 if (bp.location.url) {
                     await this.debuggerManager.setBreakpointByUrl({
@@ -122,7 +133,7 @@ export class DebuggerSessionManager {
                 logger.error('Failed to restore breakpoint:', error, bp);
                 failCount++;
             }
-        }
+        });
         if (session.pauseOnExceptions) {
             await this.debuggerManager.setPauseOnExceptions(session.pauseOnExceptions);
         }
@@ -143,23 +154,22 @@ export class DebuggerSessionManager {
         }
         const files = await fs.readdir(sessionsDir);
         const sessions = [];
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                const filePath = path.join(sessionsDir, file);
-                try {
-                    const content = await fs.readFile(filePath, 'utf-8');
-                    const session = JSON.parse(content);
-                    sessions.push({
-                        path: filePath,
-                        timestamp: session.timestamp,
-                        metadata: session.metadata,
-                    });
-                }
-                catch (error) {
-                    logger.warn(`Failed to read session file ${file}:`, error);
-                }
+        const sessionFiles = files.filter((file) => file.endsWith('.json'));
+        await this.processInBatches(sessionFiles, this.SESSION_FILE_READ_BATCH_SIZE, async (file) => {
+            const filePath = path.join(sessionsDir, file);
+            try {
+                const content = await this.readSessionFile(filePath);
+                const session = JSON.parse(content);
+                sessions.push({
+                    path: filePath,
+                    timestamp: session.timestamp,
+                    metadata: session.metadata,
+                });
             }
-        }
+            catch (error) {
+                logger.warn(`Failed to read session file ${file}:`, error);
+            }
+        });
         sessions.sort((a, b) => b.timestamp - a.timestamp);
         return sessions;
     }

package/dist/modules/debugger/ScriptManager.impl.class.d.ts

@@ -12,6 +12,9 @@ export interface ScriptInfo {
 }
 export declare class ScriptManager {
     private collector;
+    private static readonly SOURCE_LOAD_BATCH_SIZE;
+    private static readonly SEARCH_LINE_YIELD_INTERVAL;
+    private static readonly SEARCH_SCRIPT_YIELD_INTERVAL;
     private cdpSession;
     private scripts;
     private scriptsByUrl;
@@ -23,6 +26,7 @@ export declare class ScriptManager {
     constructor(collector: CodeCollector);
     init(): Promise<void>;
     private doInit;
+    private loadScriptSourceInternal;
     enable(): Promise<void>;
     getAllScripts(includeSource?: boolean, maxScripts?: number): Promise<ScriptInfo[]>;
     getScriptSource(scriptId?: string, url?: string): Promise<ScriptInfo | null>;

package/dist/modules/debugger/ScriptManager.impl.class.js

@@ -1,7 +1,11 @@
+import { setImmediate as waitForImmediate } from 'node:timers/promises';
 import { logger } from '../../utils/logger.js';
 import { extractFunctionTreeCore, } from '../debugger/ScriptManager.impl.extract-function-tree.js';
 export class ScriptManager {
     collector;
+    static SOURCE_LOAD_BATCH_SIZE = 8;
+    static SEARCH_LINE_YIELD_INTERVAL = 250;
+    static SEARCH_SCRIPT_YIELD_INTERVAL = 10;
     cdpSession = null;
     scripts = new Map();
     scriptsByUrl = new Map();
@@ -54,6 +58,25 @@ export class ScriptManager {
         this.initialized = true;
         logger.info('ScriptManager initialized');
     }
+    async loadScriptSourceInternal(script) {
+        if (script.source) {
+            return true;
+        }
+        try {
+            const { scriptSource } = await this.cdpSession.send('Debugger.getScriptSource', {
+                scriptId: script.scriptId,
+            });
+            script.source = scriptSource;
+            script.sourceLength = scriptSource.length;
+            this.buildKeywordIndex(script.scriptId, script.url, scriptSource);
+            this.chunkScript(script.scriptId, scriptSource);
+            return true;
+        }
+        catch (error) {
+            logger.warn(`Failed to get source for script ${script.scriptId}:`, error);
+            return false;
+        }
+    }
     async enable() {
         return this.init();
     }
@@ -70,23 +93,27 @@ export class ScriptManager {
             logger.warn(`Loading source code for ${limitedScripts.length} scripts. This may use significant memory.`);
             let loadedCount = 0;
             let failedCount = 0;
-            for (const script of limitedScripts) {
-                if (!script.source) {
-                    try {
-                        const { scriptSource } = await this.cdpSession.send('Debugger.getScriptSource', {
-                            scriptId: script.scriptId,
-                        });
-                        script.source = scriptSource;
+            const missingScripts = limitedScripts.filter((script) => !script.source);
+            for (let batchStart = 0; batchStart < missingScripts.length; batchStart += ScriptManager.SOURCE_LOAD_BATCH_SIZE) {
+                const batch = missingScripts.slice(batchStart, batchStart + ScriptManager.SOURCE_LOAD_BATCH_SIZE);
+                const settled = await Promise.allSettled(batch.map(async (script) => {
+                    const loaded = await this.loadScriptSourceInternal(script);
+                    if (loaded) {
                         loadedCount++;
                         if (loadedCount % 10 === 0) {
                             logger.debug(`Loaded ${loadedCount}/${limitedScripts.length} scripts...`);
                         }
                     }
-                    catch (error) {
-                        logger.warn(`Failed to get source for script ${script.scriptId}:`, error);
+                    else {
+                        failedCount++;
+                    }
+                }));
+                for (const result of settled) {
+                    if (result.status === 'rejected') {
                         failedCount++;
                     }
                 }
+                await waitForImmediate();
             }
             logger.info(`getAllScripts: ${limitedScripts.length} scripts (loaded: ${loadedCount}, failed: ${failedCount})`);
         }
@@ -121,17 +148,9 @@ export class ScriptManager {
             return null;
         }
         if (!targetScript.source) {
-            try {
-                const { scriptSource } = await this.cdpSession.send('Debugger.getScriptSource', {
-                    scriptId: targetScript.scriptId,
-                });
-                targetScript.source = scriptSource;
-                targetScript.sourceLength = scriptSource.length;
-                this.buildKeywordIndex(targetScript.scriptId, targetScript.url, scriptSource);
-                this.chunkScript(targetScript.scriptId, scriptSource);
-            }
-            catch (error) {
-                logger.error(`Failed to get script source for ${targetScript.scriptId}:`, error);
+            const loaded = await this.loadScriptSourceInternal(targetScript);
+            if (!loaded) {
+                logger.error(`Failed to get script source for ${targetScript.scriptId}`);
                 return null;
             }
         }
@@ -166,7 +185,7 @@ export class ScriptManager {
             : new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), caseSensitive ? 'g' : 'gi');
         const matches = [];
         const scripts = await this.getAllScripts(true, 500);
-        for (const script of scripts) {
+        for (const [scriptIndex, script] of scripts.entries()) {
             if (!script.source)
                 continue;
             if (matches.length >= maxMatches)
@@ -193,6 +212,12 @@ export class ScriptManager {
                         context,
                     });
                 }
+                if ((i + 1) % ScriptManager.SEARCH_LINE_YIELD_INTERVAL === 0) {
+                    await waitForImmediate();
+                }
+            }
+            if ((scriptIndex + 1) % ScriptManager.SEARCH_SCRIPT_YIELD_INTERVAL === 0) {
+                await waitForImmediate();
             }
         }
         logger.info(`searchInScripts: "${keyword}" - found ${matches.length} matches`);

package/dist/modules/emulator/EnvironmentEmulator.js

@@ -12,8 +12,8 @@ export class EnvironmentEmulator {
     llm;
     constructor(llm) {
         this.llm = llm;
-        if (llm) {
-            logger.info('LLM service unavailable, skipping AI environment analysis');
+        if (!llm) {
+            logger.debug('LLM service unavailable, skipping AI environment analysis');
         }
     }
     async analyze(options) {