erosolar-cli 1.7.436 → 1.7.439

package/dist/browser/BrowserSessionManager.js

@@ -1,713 +0,0 @@
-/**
- * Browser Session Manager - Manages browser instances, sessions, cookies, and authentication
- *
- * Provides browser-use-like functionality for AI agents:
- * - Persistent browser sessions with cookie management
- * - Authentication state persistence
- * - Multi-profile support
- * - Session recovery and cleanup
- *
- * @license MIT
- * @author Bo Shang
- */
-import { chromium, firefox, webkit } from 'playwright';
-import * as fs from 'fs';
-import * as path from 'path';
-/**
- * Browser Session Manager
- * Manages browser instances, sessions, and authentication state
- */
-export class BrowserSessionManager {
-    sessions = new Map();
-    storageDir;
-    constructor(storageDir) {
-        this.storageDir = storageDir || path.join(process.env['HOME'] || '~', '.erosolar', 'browser-sessions');
-        this.ensureStorageDir();
-    }
-    ensureStorageDir() {
-        if (!fs.existsSync(this.storageDir)) {
-            fs.mkdirSync(this.storageDir, { recursive: true });
-        }
-    }
-    /**
-     * Create a new browser session
-     */
-    async createSession(config) {
-        const sessionId = config.sessionId || `session-${Date.now()}`;
-        // Check if session already exists
-        if (this.sessions.has(sessionId)) {
-            return sessionId;
-        }
-        // Select browser type
-        const browserType = config.browserType || 'chromium';
-        const browserLauncher = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
-        // Build launch options
-        const launchOptions = {
-            headless: config.headless !== false,
-        };
-        if (config.proxy) {
-            launchOptions.proxy = config.proxy;
-        }
-        // Launch browser
-        const browser = await browserLauncher.launch(launchOptions);
-        // Build context options
-        const contextOptions = {
-            viewport: config.viewport || { width: 1920, height: 1080 },
-        };
-        if (config.userAgent) {
-            contextOptions.userAgent = config.userAgent;
-        }
-        // Apply stealth mode settings
-        if (config.stealthMode) {
-            contextOptions.userAgent = contextOptions.userAgent ||
-                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
-            contextOptions.locale = 'en-US';
-            contextOptions.timezoneId = 'America/New_York';
-            contextOptions.permissions = ['geolocation'];
-            contextOptions.extraHTTPHeaders = {
-                'Accept-Language': 'en-US,en;q=0.9',
-            };
-        }
-        // Load existing session state if available
-        const savedState = await this.loadSessionState(sessionId);
-        if (savedState && savedState.cookies.length > 0) {
-            contextOptions.storageState = {
-                cookies: savedState.cookies.map(c => ({
-                    name: c.name,
-                    value: c.value,
-                    domain: c.domain,
-                    path: c.path,
-                    expires: c.expires || -1,
-                    httpOnly: c.httpOnly || false,
-                    secure: c.secure || false,
-                    sameSite: c.sameSite || 'Lax',
-                })),
-                origins: [],
-            };
-        }
-        // Create browser context
-        const context = await browser.newContext(contextOptions);
-        // Apply stealth scripts
-        if (config.stealthMode) {
-            await this.applyStealthScripts(context);
-        }
-        // Create initial page
-        const page = await context.newPage();
-        // Set default timeout
-        page.setDefaultTimeout(config.timeout || 30000);
-        // Create session state
-        const state = {
-            sessionId,
-            browserType,
-            isActive: true,
-            createdAt: Date.now(),
-            lastAccessedAt: Date.now(),
-            isAuthenticated: savedState?.isAuthenticated || false,
-            authDomain: savedState?.authDomain,
-            cookies: savedState?.cookies || [],
-        };
-        // Store active session
-        this.sessions.set(sessionId, {
-            config,
-            browser,
-            context,
-            page,
-            state,
-        });
-        return sessionId;
-    }
-    /**
-     * Apply stealth scripts to avoid bot detection
-     */
-    async applyStealthScripts(context) {
-        await context.addInitScript(() => {
-            // Override webdriver detection
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined,
-            });
-            // Override plugins
-            Object.defineProperty(navigator, 'plugins', {
-                get: () => [1, 2, 3, 4, 5],
-            });
-            // Override languages
-            Object.defineProperty(navigator, 'languages', {
-                get: () => ['en-US', 'en'],
-            });
-            // Override permissions
-            const originalQuery = window.navigator.permissions.query;
-            window.navigator.permissions.query = (parameters) => parameters.name === 'notifications'
-                ? Promise.resolve({ state: Notification.permission })
-                : originalQuery(parameters);
-            // Override chrome runtime
-            window.chrome = {
-                runtime: {},
-            };
-        });
-    }
-    /**
-     * Get an active session
-     */
-    getSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.state.lastAccessedAt = Date.now();
-        }
-        return session;
-    }
-    /**
-     * Get the page for a session
-     */
-    getPage(sessionId) {
-        return this.getSession(sessionId)?.page;
-    }
-    /**
-     * Navigate to a URL
-     */
-    async navigateTo(sessionId, url, options) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, url: '', title: '', error: `Session ${sessionId} not found` };
-        }
-        try {
-            const response = await session.page.goto(url, {
-                waitUntil: options?.waitUntil || 'domcontentloaded',
-            });
-            session.state.currentUrl = session.page.url();
-            return {
-                success: response?.ok() ?? true,
-                url: session.page.url(),
-                title: await session.page.title(),
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                url,
-                title: '',
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Perform authentication
-     */
-    async authenticate(sessionId, authConfig) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, message: `Session ${sessionId} not found` };
-        }
-        try {
-            switch (authConfig.type) {
-                case 'form':
-                    return await this.performFormAuth(session, authConfig);
-                case 'basic':
-                    return await this.performBasicAuth(session, authConfig);
-                case 'cookie':
-                    return await this.performCookieAuth(session, authConfig);
-                case 'token':
-                    return await this.performTokenAuth(session, authConfig);
-                case 'oauth':
-                    return { success: false, message: 'OAuth authentication requires manual interaction' };
-                default:
-                    return { success: false, message: `Unknown auth type: ${authConfig.type}` };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Perform form-based authentication
-     */
-    async performFormAuth(session, authConfig) {
-        const { page } = session;
-        const { credentials, formSelectors, loginUrl, successUrl, successSelector } = authConfig;
-        if (!credentials?.username || !credentials?.password) {
-            return { success: false, message: 'Username and password required for form auth' };
-        }
-        if (!formSelectors) {
-            return { success: false, message: 'Form selectors required for form auth' };
-        }
-        // Navigate to login page if specified
-        if (loginUrl) {
-            await page.goto(loginUrl, { waitUntil: 'domcontentloaded' });
-        }
-        // Fill in credentials
-        await page.fill(formSelectors.usernameField, credentials.username);
-        await page.fill(formSelectors.passwordField, credentials.password);
-        // Submit form
-        await page.click(formSelectors.submitButton);
-        // Wait for navigation or success indicator
-        if (successUrl) {
-            await page.waitForURL(successUrl, { timeout: 10000 }).catch(() => { });
-        }
-        else if (successSelector) {
-            await page.waitForSelector(successSelector, { timeout: 10000 }).catch(() => { });
-        }
-        else {
-            await page.waitForLoadState('networkidle');
-        }
-        // Check if authentication succeeded
-        const currentUrl = page.url();
-        const isSuccess = successUrl ? currentUrl.includes(successUrl) :
-            successSelector ? await page.$(successSelector) !== null : true;
-        if (isSuccess) {
-            session.state.isAuthenticated = true;
-            session.state.authDomain = new URL(currentUrl).hostname;
-            await this.saveCookies(session);
-            return { success: true, message: 'Authentication successful' };
-        }
-        return { success: false, message: 'Authentication failed - could not verify success' };
-    }
-    /**
-     * Perform basic HTTP authentication
-     */
-    async performBasicAuth(session, authConfig) {
-        const { context } = session;
-        const { credentials } = authConfig;
-        if (!credentials?.username || !credentials?.password) {
-            return { success: false, message: 'Username and password required for basic auth' };
-        }
-        await context.setHTTPCredentials({
-            username: credentials.username,
-            password: credentials.password,
-        });
-        session.state.isAuthenticated = true;
-        return { success: true, message: 'Basic auth credentials set' };
-    }
-    /**
-     * Perform cookie-based authentication
-     */
-    async performCookieAuth(session, _authConfig) {
-        const { context } = session;
-        // Load cookies from storage
-        const savedState = await this.loadSessionState(session.state.sessionId);
-        if (savedState && savedState.cookies.length > 0) {
-            await context.addCookies(savedState.cookies.map(c => ({
-                name: c.name,
-                value: c.value,
-                domain: c.domain,
-                path: c.path,
-                expires: c.expires || -1,
-                httpOnly: c.httpOnly || false,
-                secure: c.secure || false,
-                sameSite: c.sameSite || 'Lax',
-            })));
-            session.state.isAuthenticated = true;
-            return { success: true, message: 'Cookies loaded from storage' };
-        }
-        return { success: false, message: 'No stored cookies found' };
-    }
-    /**
-     * Perform token-based authentication
-     */
-    async performTokenAuth(session, authConfig) {
-        const { context } = session;
-        const { credentials } = authConfig;
-        if (!credentials?.token) {
-            return { success: false, message: 'Token required for token auth' };
-        }
-        // Set authorization header for all requests
-        await context.setExtraHTTPHeaders({
-            'Authorization': `Bearer ${credentials.token}`,
-        });
-        session.state.isAuthenticated = true;
-        return { success: true, message: 'Token auth header set' };
-    }
-    /**
-     * Save cookies for a session
-     */
-    async saveCookies(session) {
-        const cookies = await session.context.cookies();
-        session.state.cookies = cookies.map(c => ({
-            name: c.name,
-            value: c.value,
-            domain: c.domain,
-            path: c.path,
-            expires: c.expires,
-            httpOnly: c.httpOnly,
-            secure: c.secure,
-            sameSite: c.sameSite,
-        }));
-        await this.saveSessionState(session.state);
-    }
-    /**
-     * Save session state to disk
-     */
-    async saveSessionState(state) {
-        const filePath = path.join(this.storageDir, `${state.sessionId}.json`);
-        fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf-8');
-    }
-    /**
-     * Load session state from disk
-     */
-    async loadSessionState(sessionId) {
-        const filePath = path.join(this.storageDir, `${sessionId}.json`);
-        if (fs.existsSync(filePath)) {
-            try {
-                const content = fs.readFileSync(filePath, 'utf-8');
-                return JSON.parse(content);
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * Take a screenshot
-     */
-    async takeScreenshot(sessionId, options) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            const screenshotOptions = {
-                fullPage: options?.fullPage || false,
-                type: 'png',
-            };
-            if (options?.path) {
-                screenshotOptions.path = options.path;
-                await session.page.screenshot(screenshotOptions);
-                return { success: true, path: options.path };
-            }
-            else {
-                const buffer = await session.page.screenshot(screenshotOptions);
-                return { success: true, data: buffer.toString('base64') };
-            }
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Click on an element
-     */
-    async click(sessionId, selector, options) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.click(selector, {
-                timeout: options?.timeout || 10000,
-                force: options?.force || false,
-            });
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Type text into an element
-     */
-    async type(sessionId, selector, text, options) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            if (options?.clear) {
-                await session.page.fill(selector, '');
-            }
-            await session.page.type(selector, text, { delay: options?.delay || 50 });
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Fill an input field (faster than type)
-     */
-    async fill(sessionId, selector, value) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.fill(selector, value);
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Get text content of an element
-     */
-    async getText(sessionId, selector) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            const text = await session.page.textContent(selector);
-            return { success: true, text: text || '' };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Get page HTML content
-     */
-    async getPageContent(sessionId) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            const html = await session.page.content();
-            return { success: true, html };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Wait for a selector to appear
-     */
-    async waitForSelector(sessionId, selector, options) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.waitForSelector(selector, {
-                timeout: options?.timeout || 30000,
-                state: options?.state || 'visible',
-            });
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Execute JavaScript in the page context
-     */
-    async executeScript(sessionId, script, args) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            const result = await session.page.evaluate(script, args);
-            return { success: true, result: result };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Select an option from a dropdown
-     */
-    async selectOption(sessionId, selector, value) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.selectOption(selector, value);
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Check/uncheck a checkbox
-     */
-    async setChecked(sessionId, selector, checked) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.setChecked(selector, checked);
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Upload a file
-     */
-    async uploadFile(sessionId, selector, filePath) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.page.setInputFiles(selector, filePath);
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Get all cookies for the session
-     */
-    async getCookies(sessionId, urls) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            const cookies = await session.context.cookies(urls);
-            return {
-                success: true,
-                cookies: cookies.map(c => ({
-                    name: c.name,
-                    value: c.value,
-                    domain: c.domain,
-                    path: c.path,
-                    expires: c.expires,
-                    httpOnly: c.httpOnly,
-                    secure: c.secure,
-                    sameSite: c.sameSite,
-                })),
-            };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Add cookies to the session
-     */
-    async addCookies(sessionId, cookies) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.context.addCookies(cookies.map(c => ({
-                name: c.name,
-                value: c.value,
-                domain: c.domain,
-                path: c.path,
-                expires: c.expires || -1,
-                httpOnly: c.httpOnly || false,
-                secure: c.secure || false,
-                sameSite: c.sameSite || 'Lax',
-            })));
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Clear cookies for the session
-     */
-    async clearCookies(sessionId) {
-        const session = this.getSession(sessionId);
-        if (!session) {
-            return { success: false, error: `Session ${sessionId} not found` };
-        }
-        try {
-            await session.context.clearCookies();
-            session.state.cookies = [];
-            session.state.isAuthenticated = false;
-            return { success: true };
-        }
-        catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Close a session
-     */
-    async closeSession(sessionId, saveCookies = true) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            if (saveCookies) {
-                await this.saveCookies(session);
-            }
-            session.state.isActive = false;
-            await session.page.close().catch(() => { });
-            await session.context.close().catch(() => { });
-            await session.browser.close().catch(() => { });
-            this.sessions.delete(sessionId);
-        }
-    }
-    /**
-     * Close all sessions
-     */
-    async closeAllSessions() {
-        for (const sessionId of this.sessions.keys()) {
-            await this.closeSession(sessionId);
-        }
-    }
-    /**
-     * List all stored sessions
-     */
-    listStoredSessions() {
-        if (!fs.existsSync(this.storageDir)) {
-            return [];
-        }
-        return fs.readdirSync(this.storageDir)
-            .filter(f => f.endsWith('.json'))
-            .map(f => f.replace('.json', ''));
-    }
-    /**
-     * Delete stored session data
-     */
-    deleteStoredSession(sessionId) {
-        const filePath = path.join(this.storageDir, `${sessionId}.json`);
-        if (fs.existsSync(filePath)) {
-            fs.unlinkSync(filePath);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get session info
-     */
-    getSessionInfo(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            return { ...session.state };
-        }
-        // For stored sessions, we need to load synchronously
-        const filePath = path.join(this.storageDir, `${sessionId}.json`);
-        if (fs.existsSync(filePath)) {
-            try {
-                const content = fs.readFileSync(filePath, 'utf-8');
-                return JSON.parse(content);
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if session is authenticated
-     */
-    isAuthenticated(sessionId) {
-        const session = this.sessions.get(sessionId);
-        return session?.state.isAuthenticated || false;
-    }
-}
-// Export singleton instance
-let defaultManager = null;
-export function getDefaultBrowserSessionManager() {
-    if (!defaultManager) {
-        defaultManager = new BrowserSessionManager();
-    }
-    return defaultManager;
-}
-export function createBrowserSessionManager(storageDir) {
-    return new BrowserSessionManager(storageDir);
-}
-//# sourceMappingURL=BrowserSessionManager.js.map