erosolar-cli 1.5.14 → 1.6.0

package/dist/browser/BrowserSessionManager.js

@@ -0,0 +1,713 @@
+/**
+ * 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: 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