@jshookmcp/jshook 0.1.4 → 0.1.6

package/dist/cli/doctor.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/doctor.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { formatEnvironmentDoctorReport, runEnvironmentDoctor } from '../utils/environmentDoctor.js';
+const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
+process.stdout.write(`${formatEnvironmentDoctorReport(report)}\n`);
+process.exit(0);

package/dist/constants.d.ts

@@ -103,6 +103,7 @@ export declare const MEMORY_SCAN_MAX_RESULTS: number;
 export declare const MEMORY_SCAN_MAX_REGIONS: number;
 export declare const MEMORY_SCAN_REGION_MAX_BYTES: number;
 export declare const MEMORY_INJECT_TIMEOUT_MS: number;
+export declare const ENABLE_INJECTION_TOOLS: boolean;
 export declare const MEMORY_MONITOR_INTERVAL_MS: number;
 export declare const MEMORY_VMMAP_TIMEOUT_MS: number;
 export declare const MEMORY_PROTECTION_QUERY_TIMEOUT_MS: number;
@@ -113,4 +114,3 @@ export declare const PROCESS_LAUNCH_WAIT_MS: number;
 export declare const WIN_DEBUG_PORT_POLL_ATTEMPTS: number;
 export declare const WIN_DEBUG_PORT_POLL_INTERVAL_MS: number;
 export declare const PACKER_SANDBOX_TIMEOUT_MS: number;
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -12,6 +12,17 @@ const float = (key, fallback) => {
     const n = Number.parseFloat(v);
     return Number.isFinite(n) ? n : fallback;
 };
+const bool = (key, fallback) => {
+    const v = process.env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const normalized = v.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1')
+        return true;
+    if (normalized === 'false' || normalized === '0')
+        return false;
+    return fallback;
+};
 const str = (key, fallback) => process.env[key] || fallback;
 const list = (key, fallback) => {
     const v = process.env[key];
@@ -84,7 +95,7 @@ export const CAPTCHA_RESULT_TIMEOUT_MS = int('CAPTCHA_RESULT_TIMEOUT_MS', 10_000
 export const CAPTCHA_DEFAULT_TIMEOUT_MS = int('CAPTCHA_DEFAULT_TIMEOUT_MS', 180_000);
 export const CAPTCHA_MIN_TIMEOUT_MS = int('CAPTCHA_MIN_TIMEOUT_MS', 5_000);
 export const CAPTCHA_MAX_TIMEOUT_MS = int('CAPTCHA_MAX_TIMEOUT_MS', 600_000);
-export const CAPTCHA_MAX_RETRIES = int('CAPTCHA_MAX_RETRIES_MAX', 5);
+export const CAPTCHA_MAX_RETRIES = int('CAPTCHA_MAX_RETRIES', 5);
 export const CAPTCHA_DEFAULT_RETRIES = int('CAPTCHA_DEFAULT_RETRIES', 2);
 export const NETWORK_REPLAY_TIMEOUT_MS = int('NETWORK_REPLAY_TIMEOUT_MS', 30_000);
 export const NETWORK_REPLAY_MAX_BODY_BYTES = int('NETWORK_REPLAY_MAX_BODY_BYTES', 512_000);
@@ -137,6 +148,7 @@ export const MEMORY_SCAN_MAX_RESULTS = int('MEMORY_SCAN_MAX_RESULTS', 10_000);
 export const MEMORY_SCAN_MAX_REGIONS = int('MEMORY_SCAN_MAX_REGIONS', 50_000);
 export const MEMORY_SCAN_REGION_MAX_BYTES = int('MEMORY_SCAN_REGION_MAX_BYTES', 16_777_216);
 export const MEMORY_INJECT_TIMEOUT_MS = int('MEMORY_INJECT_TIMEOUT_MS', 30_000);
+export const ENABLE_INJECTION_TOOLS = bool('ENABLE_INJECTION_TOOLS', false);
 export const MEMORY_MONITOR_INTERVAL_MS = int('MEMORY_MONITOR_INTERVAL_MS', 1_000);
 export const MEMORY_VMMAP_TIMEOUT_MS = int('MEMORY_VMMAP_TIMEOUT_MS', 15_000);
 export const MEMORY_PROTECTION_QUERY_TIMEOUT_MS = int('MEMORY_PROTECTION_QUERY_TIMEOUT_MS', 15_000);
@@ -147,4 +159,3 @@ export const PROCESS_LAUNCH_WAIT_MS = int('PROCESS_LAUNCH_WAIT_MS', 2_000);
 export const WIN_DEBUG_PORT_POLL_ATTEMPTS = int('WIN_DEBUG_PORT_POLL_ATTEMPTS', 20);
 export const WIN_DEBUG_PORT_POLL_INTERVAL_MS = int('WIN_DEBUG_PORT_POLL_INTERVAL_MS', 500);
 export const PACKER_SANDBOX_TIMEOUT_MS = int('PACKER_SANDBOX_TIMEOUT_MS', 3_000);
-//# sourceMappingURL=constants.js.map

package/dist/errors/PrerequisiteError.d.ts

@@ -2,4 +2,3 @@ import { ToolError } from './ToolError.js';
 export declare class PrerequisiteError extends ToolError {
     constructor(message: string);
 }
-//# sourceMappingURL=PrerequisiteError.d.ts.map

package/dist/errors/PrerequisiteError.js

@@ -5,4 +5,3 @@ export class PrerequisiteError extends ToolError {
         this.name = 'PrerequisiteError';
     }
 }
-//# sourceMappingURL=PrerequisiteError.js.map

package/dist/errors/ToolError.d.ts

@@ -10,4 +10,3 @@ export declare class ToolError extends Error {
         cause?: Error;
     });
 }
-//# sourceMappingURL=ToolError.d.ts.map

package/dist/errors/ToolError.js

@@ -15,4 +15,3 @@ export class ToolError extends Error {
         this.details = options?.details;
     }
 }
-//# sourceMappingURL=ToolError.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,6 +4,7 @@ import { getConfig, validateConfig } from './utils/config.js';
 import { logger } from './utils/logger.js';
 import { initRegistry } from './server/registry/index.js';
 import { resolveCliFastPath } from './utils/cliFastPath.js';
+import { cleanupArtifacts, getArtifactRetentionConfig, startArtifactRetentionScheduler } from './utils/artifactRetention.js';
 const FATAL_ERROR_CODES = new Set([
     'ERR_WORKER_OUT_OF_MEMORY',
     'ERR_MEMORY_ALLOCATION_FAILED',
@@ -53,9 +54,17 @@ async function main() {
         if (config.llm.provider === 'anthropic' && !config.llm.anthropic?.apiKey) {
             logger.warn('ANTHROPIC_API_KEY is not configured. AI-assisted tools may return configuration errors.');
         }
+        const artifactRetention = getArtifactRetentionConfig();
+        if (artifactRetention.cleanupOnStart && artifactRetention.enabled) {
+            const cleanup = await cleanupArtifacts();
+            if (cleanup.removedFiles > 0) {
+                logger.info(`[artifacts] Startup cleanup removed ${cleanup.removedFiles} files (${cleanup.removedBytes} bytes)`);
+            }
+        }
         logger.info('Creating MCP server instance...');
         await initRegistry();
         const server = new MCPServer(config);
+        const stopArtifactRetentionScheduler = startArtifactRetentionScheduler();
         const recoveryWindowMs = Math.max(1000, parseInt(process.env.RUNTIME_ERROR_WINDOW_MS ?? '60000', 10));
         const maxRecoverableErrors = Math.max(1, parseInt(process.env.RUNTIME_ERROR_THRESHOLD ?? '5', 10));
         const runtimeRecovery = {
@@ -83,11 +92,13 @@ async function main() {
         };
         process.on('SIGINT', async () => {
             logger.info('Received SIGINT, shutting down...');
+            stopArtifactRetentionScheduler?.();
             await server.close();
             process.exit(0);
         });
         process.on('SIGTERM', async () => {
             logger.info('Received SIGTERM, shutting down...');
+            stopArtifactRetentionScheduler?.();
             await server.close();
             process.exit(0);
         });
@@ -126,4 +137,3 @@ if (cliFastPath.handled) {
     process.exit(cliFastPath.exitCode);
 }
 main();
-//# sourceMappingURL=index.js.map

package/dist/modules/analyzer/AISummarizer.d.ts

@@ -37,4 +37,3 @@ export declare class AISummarizer {
     private parseSummaryResponse;
     private basicAnalysis;
 }
-//# sourceMappingURL=AISummarizer.d.ts.map

package/dist/modules/analyzer/AISummarizer.js

@@ -120,4 +120,3 @@ export class AISummarizer {
         };
     }
 }
-//# sourceMappingURL=AISummarizer.js.map

package/dist/modules/analyzer/CodeAnalyzer.d.ts

@@ -13,4 +13,3 @@ export declare class CodeAnalyzer {
     private calculateComplexity;
     private analyzeDataFlow;
 }
-//# sourceMappingURL=CodeAnalyzer.d.ts.map

package/dist/modules/analyzer/CodeAnalyzer.js

@@ -365,4 +365,3 @@ export class CodeAnalyzer {
         return analyzeDataFlowWithTaint(code, this.llm);
     }
 }
-//# sourceMappingURL=CodeAnalyzer.js.map

package/dist/modules/analyzer/CodeAnalyzerDataFlow.d.ts

@@ -1,4 +1,3 @@
 import type { DataFlow } from '../../types/index.js';
 import type { LLMService } from '../../services/LLMService.js';
 export declare function analyzeDataFlowWithTaint(code: string, llm?: LLMService): Promise<DataFlow>;
-//# sourceMappingURL=CodeAnalyzerDataFlow.d.ts.map

package/dist/modules/analyzer/CodeAnalyzerDataFlow.js

@@ -399,4 +399,3 @@ function checkTaintedArguments(args, taintMap, taintPaths, _funcName, line) {
         }
     });
 }
-//# sourceMappingURL=CodeAnalyzerDataFlow.js.map

package/dist/modules/analyzer/IntelligentAnalyzer.d.ts

@@ -96,4 +96,3 @@ export declare class IntelligentAnalyzer {
         exceptions: ExceptionInfo[];
     }): Promise<AnalysisResult>;
 }
-//# sourceMappingURL=IntelligentAnalyzer.d.ts.map

package/dist/modules/analyzer/IntelligentAnalyzer.js

@@ -69,32 +69,40 @@ export class IntelligentAnalyzer {
     }
     generateAIFriendlySummary(result) {
         const lines = [];
-        lines.push('===  ===\n');
-        lines.push(` :`);
+        lines.push('=== Analysis Summary ===');
+        lines.push('');
+        lines.push(`Statistics:`);
         lines.push(`  - Requests: ${result.summary.totalRequests} -> Filtered: ${result.summary.filteredRequests}`);
         lines.push(`  - Logs: ${result.summary.totalLogs} -> Filtered: ${result.summary.filteredLogs}`);
-        lines.push(`  - : ${result.exceptions.length}\n`);
+        lines.push(`  - Exceptions: ${result.exceptions.length}`);
+        lines.push('');
         if (result.summary.suspiciousAPIs.length > 0) {
-            lines.push(` API (${result.summary.suspiciousAPIs.length}):`);
+            lines.push(`Suspicious APIs (${result.summary.suspiciousAPIs.length}):`);
             result.summary.suspiciousAPIs.slice(0, 10).forEach((api) => {
                 lines.push(`  - ${api}`);
             });
             lines.push('');
         }
         if (result.patterns.encryption && result.patterns.encryption.length > 0) {
-            lines.push(`  (${result.patterns.encryption.length}):`);
+            lines.push(`Encryption Patterns (${result.patterns.encryption.length}):`);
             result.patterns.encryption.slice(0, 5).forEach((pattern) => {
-                lines.push(`  - ${pattern.type} (: ${(pattern.confidence * 100).toFixed(0)}%)`);
-                lines.push(`    : ${pattern.location}`);
-                lines.push(`    : ${pattern.evidence.join(', ')}`);
+                const evidence = Array.isArray(pattern.evidence)
+                    ? pattern.evidence.join(', ')
+                    : String(pattern.evidence ?? '');
+                lines.push(`  - ${pattern.type} (confidence: ${(pattern.confidence * 100).toFixed(0)}%)`);
+                lines.push(`    location: ${pattern.location}`);
+                lines.push(`    evidence: ${evidence}`);
             });
             lines.push('');
         }
         if (result.patterns.signature && result.patterns.signature.length > 0) {
             lines.push(`Signature Patterns (${result.patterns.signature.length}):`);
             result.patterns.signature.slice(0, 5).forEach((pattern) => {
+                const parameters = Array.isArray(pattern.parameters)
+                    ? pattern.parameters.join(', ')
+                    : String(pattern.parameters ?? '');
                 lines.push(`  - ${pattern.type}`);
-                lines.push(`    : ${pattern.parameters.join(', ')}`);
+                lines.push(`    parameters: ${parameters}`);
             });
             lines.push('');
         }
@@ -106,11 +114,11 @@ export class IntelligentAnalyzer {
             lines.push('');
         }
         if (result.summary.keyFunctions.length > 0) {
-            lines.push(`  (${result.summary.keyFunctions.length}):`);
+            lines.push(`Key Functions (${result.summary.keyFunctions.length}):`);
             lines.push(`  ${result.summary.keyFunctions.slice(0, 15).join(', ')}`);
             lines.push('');
         }
-        lines.push('===  ===');
+        lines.push('=== Analysis Summary ===');
         return lines.join('\n');
     }
     async analyzeCriticalRequestsWithLLM(requests) {
@@ -246,4 +254,3 @@ export class IntelligentAnalyzer {
         return ruleBasedResult;
     }
 }
-//# sourceMappingURL=IntelligentAnalyzer.js.map

package/dist/modules/analyzer/PatternDetector.d.ts

@@ -19,4 +19,3 @@ export declare function detectTokenPatterns(requests: NetworkRequest[], _logs: C
 export declare function detectAntiDebugPatterns(logs: ConsoleMessage[]): AntiDebugPattern[];
 export declare function extractSuspiciousAPIs(requests: NetworkRequest[]): string[];
 export declare function extractKeyFunctions(logs: ConsoleMessage[]): string[];
-//# sourceMappingURL=PatternDetector.d.ts.map

package/dist/modules/analyzer/PatternDetector.js

@@ -273,4 +273,3 @@ export function extractKeyFunctions(logs) {
     }
     return Array.from(functions).slice(0, 30);
 }
-//# sourceMappingURL=PatternDetector.js.map

package/dist/modules/analyzer/PatternDetectorAuthPatterns.d.ts

@@ -2,4 +2,3 @@ import type { NetworkRequest } from '../monitor/ConsoleMonitor.js';
 import type { SignaturePattern, TokenPattern } from '../analyzer/IntelligentAnalyzer.js';
 export declare function detectSignaturePatternsInternal(requests: NetworkRequest[]): SignaturePattern[];
 export declare function detectTokenPatternsInternal(requests: NetworkRequest[]): TokenPattern[];
-//# sourceMappingURL=PatternDetectorAuthPatterns.d.ts.map

package/dist/modules/analyzer/PatternDetectorAuthPatterns.js

@@ -271,4 +271,3 @@ export function detectTokenPatternsInternal(requests) {
     }
     return patterns;
 }
-//# sourceMappingURL=PatternDetectorAuthPatterns.js.map

package/dist/modules/analyzer/QualityAnalyzer.d.ts

@@ -39,4 +39,3 @@ export declare function detectDuplicateCode(ast: t.File): Array<{
 export declare function computeASTHash(node: t.Node): string;
 export declare function normalizeCode(node: t.Node): string;
 export declare function calculateCodeSimilarity(code1: string, code2: string): number;
-//# sourceMappingURL=QualityAnalyzer.d.ts.map

package/dist/modules/analyzer/QualityAnalyzer.js

@@ -431,4 +431,3 @@ export function calculateCodeSimilarity(code1, code2) {
     const maxLen = Math.max(len1, len2);
     return 1 - distance / maxLen;
 }
-//# sourceMappingURL=QualityAnalyzer.js.map

package/dist/modules/analyzer/SecurityCodeAnalyzer.d.ts

@@ -3,4 +3,3 @@ import type { SecurityRisk } from '../../types/index.js';
 export declare function getMemberExpressionName(node: t.MemberExpression): string;
 export declare function checkSanitizer(node: t.CallExpression, sanitizers: Set<string>): boolean;
 export declare function identifySecurityRisks(code: string, aiAnalysis: Record<string, unknown>): SecurityRisk[];
-//# sourceMappingURL=SecurityCodeAnalyzer.d.ts.map

package/dist/modules/analyzer/SecurityCodeAnalyzer.js

@@ -184,4 +184,3 @@ export function identifySecurityRisks(code, aiAnalysis) {
         self.findIndex((r) => r.type === risk.type && r.location.line === risk.location.line));
     return uniqueRisks;
 }
-//# sourceMappingURL=SecurityCodeAnalyzer.js.map

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

@@ -27,4 +27,3 @@ export declare class BrowserDiscovery {
     private checkDebugPortFromCommandLine;
     private checkPort;
 }
-//# sourceMappingURL=BrowserDiscovery.d.ts.map

package/dist/modules/browser/BrowserDiscovery.js

@@ -247,4 +247,3 @@ export class BrowserDiscovery {
         }
     }
 }
-//# sourceMappingURL=BrowserDiscovery.js.map

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

@@ -10,23 +10,27 @@ export declare class BrowserModeManager {
     private browser;
     private currentPage;
     private isHeadless;
+    private isClosing;
+    private launchPromise?;
     private config;
     private captchaDetector;
     private launchOptions;
     private sessionData;
     constructor(config?: BrowserModeConfig, launchOptions?: LaunchOptions);
     launch(): Promise<Browser>;
+    private doLaunch;
     private resolveExecutablePath;
     newPage(): Promise<Page>;
+    private finalizeClose;
     goto(url: string, page?: Page): Promise<Page>;
     checkAndHandleCaptcha(page: Page, originalUrl: string): Promise<void>;
     private switchToHeaded;
     private showCaptchaPrompt;
     private saveSessionData;
+    private restoreSessionData;
     private injectAntiDetectionScripts;
     close(): Promise<void>;
     getBrowser(): Browser | null;
     getCurrentPage(): Page | null;
     isHeadlessMode(): boolean;
 }
-//# sourceMappingURL=BrowserModeManager.d.ts.map

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;
@@ -282,4 +368,3 @@ export class BrowserModeManager {
         return this.isHeadless;
     }
 }
-//# sourceMappingURL=BrowserModeManager.js.map

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>;
@@ -42,4 +46,3 @@ export declare class CamoufoxBrowserManager {
     getBrowser(): CamoufoxBrowserLike | null;
     getCDPSession(page: CamoufoxPageLike): Promise<unknown>;
 }
-//# sourceMappingURL=CamoufoxBrowserManager.d.ts.map