coffeeinabit 0.0.1

package/linkedin_automation.js

@@ -0,0 +1,784 @@
+import { firefox } from 'playwright';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { humanLikeType, readLinkedInCredentials } from './tools/human_typing.js';
+import { executeGetProfile } from './tools/get_profile.js';
+import { executeLikePost } from './tools/like_post.js';
+import { executeSendConnectionRequest } from './tools/send_connection_request.js';
+import { executeSendMessages } from './tools/send_messages.js';
+import { executeCommentPost } from './tools/comment_post.js';
+import { executeGetMessages } from './tools/get_messages.js';
+import { executeCheckConnectionStatus } from './tools/check_connection_status.js';
+import { executeLinkedInSearch } from './tools/get_linkedin_search_results.js';
+import { executeGetDailyLinkedInConnections } from './tools/get_daily_linkedin_connections.js';
+import { executeGetNewMessages } from './tools/get_new_messages.js';
+import { executeGetLinkedInUpdates } from './tools/get_linkedin_updates.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class LinkedInAutomation {
+  constructor(io) {
+    this.io = io;
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.isRunning = false;
+    this.status = 'idle';
+    this.currentUrl = '';
+    this.title = '';
+    this.screenshotInterval = null;
+    this.actionPollingInterval = null;
+    this.screenshotIntervalMs = 3000;
+    this.actionPollingIntervalMs = 15000;
+    this.currentAction = null;
+    this.userEmail = null;
+    this.isActionPollingActive = false;
+    this.linkedInSessionDir = path.join(__dirname, 'context');
+  }
+
+  getLinkedInSessionPath() {
+    const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
+    return path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}.json`);
+  }
+
+  async saveLinkedInSession() {
+    try {
+      if (!this.context || !this.page) {
+        console.error('[LinkedInAutomation] Cannot save session - no context or page');
+        return false;
+      }
+
+      console.log('[LinkedInAutomation] Saving LinkedIn session...');
+      
+      const cookies = await this.context.cookies();
+      const localStorage = await this.page.evaluate(() => {
+        const items = [];
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          items.push({
+            name: key,
+            value: window.localStorage.getItem(key)
+          });
+        }
+        return items;
+      });
+
+      const sessionData = {
+        cookies: cookies,
+        origins: [
+          {
+            origin: 'https://www.linkedin.com',
+            localStorage: localStorage
+          }
+        ]
+      };
+
+      if (!fs.existsSync(this.linkedInSessionDir)) {
+        fs.mkdirSync(this.linkedInSessionDir, { recursive: true });
+      }
+
+      const sessionPath = this.getLinkedInSessionPath();
+      fs.writeFileSync(sessionPath, JSON.stringify(sessionData, null, 2));
+      
+      console.log('[LinkedInAutomation] LinkedIn session saved to:', sessionPath);
+      return true;
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error saving LinkedIn session:', error);
+      return false;
+    }
+  }
+
+  async loadLinkedInSession() {
+    try {
+      const sessionPath = this.getLinkedInSessionPath();
+      
+      if (!fs.existsSync(sessionPath)) {
+        console.log('[LinkedInAutomation] No saved LinkedIn session found at:', sessionPath);
+        return false;
+      }
+
+      console.log('[LinkedInAutomation] Loading LinkedIn session from:', sessionPath);
+      
+      const sessionData = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+      
+      if (!this.context) {
+        console.error('[LinkedInAutomation] Cannot load session - no context');
+        return false;
+      }
+
+      if (sessionData.cookies && sessionData.cookies.length > 0) {
+        await this.context.addCookies(sessionData.cookies);
+        console.log(`[LinkedInAutomation] Loaded ${sessionData.cookies.length} cookies`);
+      }
+
+      if (sessionData.origins && sessionData.origins.length > 0) {
+        for (const origin of sessionData.origins) {
+          if (origin.localStorage && origin.localStorage.length > 0) {
+            console.log(`[LinkedInAutomation] Restoring ${origin.localStorage.length} localStorage items for ${origin.origin}`);
+          }
+        }
+      }
+
+      console.log('[LinkedInAutomation] LinkedIn session loaded successfully');
+      return true;
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error loading LinkedIn session:', error);
+      return false;
+    }
+  }
+
+  async restoreLocalStorage() {
+    try {
+      const sessionPath = this.getLinkedInSessionPath();
+      
+      if (!fs.existsSync(sessionPath)) {
+        return false;
+      }
+
+      const sessionData = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+      
+      if (!this.page) {
+        return false;
+      }
+
+      if (sessionData.origins && sessionData.origins.length > 0) {
+        for (const origin of sessionData.origins) {
+          if (origin.localStorage && origin.localStorage.length > 0) {
+            await this.page.evaluate((items) => {
+              for (const item of items) {
+                try {
+                  window.localStorage.setItem(item.name, item.value);
+                } catch (e) {
+                  console.error('Error setting localStorage item:', e);
+                }
+              }
+            }, origin.localStorage);
+            console.log(`[LinkedInAutomation] Restored ${origin.localStorage.length} localStorage items`);
+          }
+        }
+      }
+
+      return true;
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error restoring localStorage:', error);
+      return false;
+    }
+  }
+
+  async startAutomation(headless = false) {
+    try {
+      console.log('[LinkedInAutomation] Starting automation...');
+      this.headless = headless;
+      this.originalHeadless = headless;
+      this.needsManualLogin = false;
+      console.log(`[LinkedInAutomation] Browser mode: ${headless ? 'headless' : 'visible'}`);
+      this.status = 'starting';
+      this.emitStatus();
+
+      this.userEmail = this._currentUserEmail || 'default_user';
+      console.log('[LinkedInAutomation] User email:', this.userEmail);
+
+      console.log('[LinkedInAutomation] Launching browser for login...');
+      await this.launchBrowserAndLogin();
+
+      this.setupPageListeners();
+
+      this.isRunning = true;
+      this.status = 'running';
+      this.emitStatus();
+
+      this.startScreenshotCapture();
+
+    } catch (error) {
+      console.error('[LinkedInAutomation] Failed to start automation:', error);
+      this.status = 'error';
+      this.emitStatus();
+      throw error;
+    }
+  }
+
+  setupPageListeners() {
+    if (!this.page) return;
+
+    this.page.on('load', () => {
+      this.updatePageInfo();
+    });
+
+    this.page.on('framenavigated', (frame) => {
+      if (frame === this.page.mainFrame()) {
+        this.updatePageInfo();
+      }
+    });
+
+    this.page.on('pageerror', (error) => {
+      console.error('[Browser Error]', error.message);
+    });
+  }
+
+  async updatePageInfo() {
+    if (!this.page) return;
+
+    try {
+      this.currentUrl = this.page.url();
+      this.title = await this.page.title();
+      
+      console.log('[LinkedInAutomation] Page updated:', {
+        url: this.currentUrl,
+        title: this.title
+      });
+
+      this.emitPageUpdate();
+
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error updating page info:', error);
+    }
+  }
+
+  async startLinkedInLogin() {
+    try {
+      if (this.originalHeadless && !this.needsManualLogin) {
+        console.log('[LinkedInAutomation] Manual login needed in headless mode. Switching to visible browser...');
+        this.needsManualLogin = true;
+        this.status = 'manual_login_needed';
+        this.emitStatus();
+        
+        await this.closeBrowser();
+        
+        this.headless = false;
+        await this.launchBrowserAndLogin();
+        
+        this.setupPageListeners();
+        return;
+      }
+
+      console.log('[LinkedInAutomation] Navigating to LinkedIn login page...');
+      await this.page.goto('https://www.linkedin.com/login', { 
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+      });
+      
+      try {
+        console.log('[LinkedInAutomation] Loading credentials...');
+        const credentials = await readLinkedInCredentials();
+
+        
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        console.log('[LinkedInAutomation] Waiting for login form...');
+        await this.page.waitForSelector('#username', { timeout: 10000 });
+        
+        console.log('[LinkedInAutomation] Filling in email with human-like typing...');
+        const emailInput = this.page.locator('#username');
+        await humanLikeType(emailInput, credentials.email);
+        
+        console.log('[LinkedInAutomation] Filling in password with human-like typing...');
+        const passwordInput = this.page.locator('#password');
+        await humanLikeType(passwordInput, credentials.password);
+        
+        console.log('[LinkedInAutomation] Clicking sign in button...');
+        await this.page.click('button[type="submit"]');
+        
+        this.status = 'waiting_for_captcha';
+        this.emitStatus();
+        console.log('[LinkedInAutomation] Waiting for user to complete captcha/verification...');
+      } catch (credError) {
+        console.log('[LinkedInAutomation] No credentials found or error loading credentials:', credError.message);
+        console.log('[LinkedInAutomation] Waiting for user to login manually...');
+        this.status = 'waiting_for_manual_login';
+        this.emitStatus();
+      }
+
+      const loginStartTime = Date.now();
+      const loginTimeoutMs = 10 * 60 * 1000;
+
+      const pollInterval = setInterval(async () => {
+        try {
+          if (!this.page || !this.isRunning) {
+            console.log('[LinkedInAutomation] Login polling stopped - page:', !!this.page, 'isRunning:', this.isRunning);
+            clearInterval(pollInterval);
+            return;
+          }
+
+          if (Date.now() - loginStartTime > loginTimeoutMs) {
+            console.log('[LinkedInAutomation] LinkedIn login timed out after 10 minutes.');
+            this.status = 'error';
+            this.emitStatus();
+            await this.stopAutomation();
+            clearInterval(pollInterval);
+            return;
+          }
+
+          await this.updatePageInfo();
+          console.log('[LinkedInAutomation] Login polling - checking URL:', this.currentUrl);
+
+          if (this.currentUrl.includes('/feed')) {
+            console.log('[LinkedInAutomation] Login successful! Detected /feed/ URL');
+            
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            const secondCheck = this.page.url();
+            if (secondCheck.includes('/feed')) {
+              console.log('[LinkedInAutomation] Second check confirmed - still on /feed/');
+              
+              console.log('[LinkedInAutomation] Saving LinkedIn session for future use...');
+              await this.saveLinkedInSession();
+              
+              this.status = 'linkedin_logged_in';
+              this.emitStatus();
+              
+              if (this.originalHeadless && this.needsManualLogin) {
+                console.log('[LinkedInAutomation] Manual login completed. Switching back to headless mode...');
+                clearInterval(pollInterval);
+                
+                this.status = 'switching_to_headless';
+                this.emitStatus();
+                
+                this.stopScreenshotCapture();
+                
+                await this.closeBrowser();
+                
+                this.headless = true;
+                console.log('[LinkedInAutomation] Relaunching browser in headless mode...');
+                await this.launchBrowserAndLogin();
+                
+                this.setupPageListeners();
+                this.startScreenshotCapture();
+                
+                this.status = 'linkedin_logged_in';
+                this.emitStatus();
+              }
+              
+              console.log('[LinkedInAutomation] Starting action polling after successful login...');
+              this.startActionPolling();
+              
+              clearInterval(pollInterval);
+            } else {
+              console.log('[LinkedInAutomation] Second check failed - not on /feed/ anymore, continuing to wait...');
+            }
+          }
+        } catch (error) {
+          console.error('[LinkedInAutomation] Error during login polling:', error);
+        }
+      }, 2000); 
+
+    } catch (error) {
+      console.error('[LinkedInAutomation] Failed to navigate to LinkedIn:', error);
+      this.status = 'error';
+      this.emitStatus();
+      throw error;
+    }
+  }
+
+
+  async closeBrowser() {
+    try {
+      console.log('[LinkedInAutomation] Closing browser...');
+      
+      if (this.page) {
+        await this.page.close();
+        this.page = null;
+      }
+
+      if (this.context) {
+        await this.context.close();
+        this.context = null;
+      }
+
+      if (this.browser) {
+        await this.browser.close();
+        this.browser = null;
+      }
+
+      console.log('[LinkedInAutomation] Browser closed successfully');
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error closing browser:', error);
+    }
+  }
+
+  async stopAutomation() {
+    try {
+      console.log('[LinkedInAutomation] Stopping automation...');
+      this.status = 'stopping';
+      this.emitStatus();
+
+      this.stopScreenshotCapture();
+      this.stopActionPolling();
+
+      await this.closeBrowser();
+
+      this.status = 'stopped';
+      this.emitStatus();
+
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error stopping automation:', error);
+      this.status = 'error';
+      this.emitStatus();
+    }
+  }
+
+  emitStatus() {
+    if (this.io) {
+      this.io.emit('automation_status', {
+        status: this.status,
+        isRunning: this.isRunning,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  emitPageUpdate() {
+    if (this.io) {
+      this.io.emit('page_update', {
+        url: this.currentUrl,
+        title: this.title,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  emitActionUpdate() {
+    if (this.io) {
+      this.io.emit('action_update', {
+        currentAction: this.currentAction,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  startScreenshotCapture() {
+    console.log('[LinkedInAutomation] Starting screenshot capture...');
+    
+    this.screenshotInterval = setInterval(async () => {
+      await this.captureScreenshot();
+    }, this.screenshotIntervalMs);
+  }
+
+  stopScreenshotCapture() {
+    if (this.screenshotInterval) {
+      clearInterval(this.screenshotInterval);
+      this.screenshotInterval = null;
+      console.log('[LinkedInAutomation] Screenshot capture stopped');
+    }
+  }
+
+  async captureScreenshot() {
+    if (!this.page) return;
+
+    try {
+      const screenshot = await this.page.screenshot({
+        fullPage: false,
+        clip: { x: 0, y: 0, width: 1200, height: 800 },
+        type: 'png',
+        timeout: 60000
+      });
+
+      const base64Screenshot = screenshot.toString('base64');
+      
+      this.io.emit('screenshot_update', {
+        screenshot: base64Screenshot,
+        url: this.currentUrl,
+        title: this.title,
+        timestamp: new Date().toISOString()
+      });
+
+    } catch (error) {
+      console.error('[LinkedInAutomation] Failed to capture screenshot:', error.message);
+    }
+  }
+
+  startActionPolling() {
+    if (this.isActionPollingActive) {
+      console.log('[LinkedInAutomation] Action polling is already active, skipping...');
+      return;
+    }
+
+    console.log('[LinkedInAutomation] Starting action polling with random intervals (20-40 seconds)...');
+    this.isActionPollingActive = true;
+    
+    const pollWithRandomInterval = async () => {
+      if (!this.isActionPollingActive) {
+        console.log('[LinkedInAutomation] Action polling stopped, not scheduling next poll');
+        return;
+      }
+
+      if (this.currentAction) {
+        console.log('[LinkedInAutomation] Action in progress, skipping polling...');
+        const randomInterval = Math.floor(Math.random() * 20000) + 20000;
+        setTimeout(pollWithRandomInterval, randomInterval);
+        return;
+      }
+      
+      await this.pollForActions();
+      
+      const randomInterval = Math.floor(Math.random() * 20000) + 20000;
+      console.log('[LinkedInAutomation] Next poll in', randomInterval / 1000, 'seconds');
+      
+      setTimeout(pollWithRandomInterval, randomInterval);
+    };
+    
+    pollWithRandomInterval();
+  }
+
+  stopActionPolling() {
+    console.log('[LinkedInAutomation] Action polling stopped');
+    this.isActionPollingActive = false;
+  }
+
+  async pollForActions() {
+    try {
+      console.log('[LinkedInAutomation] Polling for actions from backend...');
+      
+      const idToken = this.getAccessToken();
+      if (!idToken) {
+        console.error('[LinkedInAutomation] No id_token available for authentication');
+        return;
+      }
+      
+      console.log('[LinkedInAutomation] Using id_token for authentication:', idToken.substring(0, 20) + '...');
+      
+      const response = await fetch('https://api.coffeeinabit.com/app/actions', {
+        headers: {
+          'Authorization': `Bearer ${idToken}`,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      if (response.ok) {
+        const responseData = await response.json();
+        console.log('[LinkedInAutomation] Full response from backend:', JSON.stringify(responseData, null, 2));
+        
+        const actions = responseData.actions || [];
+        console.log('[LinkedInAutomation] Received actions from backend:', actions.length, 'actions');
+        
+        if (actions && actions.length > 0) {
+          console.log('[LinkedInAutomation] Processing actions:', actions.map(a => `${a.action} (${a.action_id})`).join(', '));
+          for (const action of actions) {
+            await this.executeAction(action);
+          }
+        } else {
+          console.log('[LinkedInAutomation] No actions to execute, continuing to poll...');
+        }
+      } else {
+        console.error('[LinkedInAutomation] Failed to fetch actions. Status:', response.status, response.statusText);
+        const errorText = await response.text();
+        console.error('[LinkedInAutomation] Error response:', errorText);
+      }
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error polling for actions:', error.message);
+      console.error('[LinkedInAutomation] Full error:', error);
+    }
+  }
+
+  async executeAction(action) {
+    console.log('[LinkedInAutomation] Starting execution of action:', action.action, 'ID:', action.action_id);
+    console.log('[LinkedInAutomation] Action parameters:', JSON.stringify(action.parameters, null, 2));
+    this.currentAction = action;
+    this.emitActionUpdate();
+    
+    try {
+      let result = null;
+      
+      switch (action.action) {
+        case 'get_profile':
+          console.log('[LinkedInAutomation] Executing get_profile action...');
+          result = await executeGetProfile(this.page, action);
+          console.log('[LinkedInAutomation] get_profile result:', result);
+          break;
+        case 'like_post':
+          console.log('[LinkedInAutomation] Executing like_post action...');
+          result = await executeLikePost(this.page, action);
+          console.log('[LinkedInAutomation] like_post result:', result);
+          break;
+        case 'send_connection_request':
+          console.log('[LinkedInAutomation] Executing send_connection_request action...');
+          result = await executeSendConnectionRequest(this.page, action);
+          console.log('[LinkedInAutomation] send_connection_request result:', result);
+          break;
+        case 'send_messages':
+          console.log('[LinkedInAutomation] Executing send_messages action...');
+          result = await executeSendMessages(this.page, action);
+          console.log('[LinkedInAutomation] send_messages result:', result);
+          break;
+        case 'comment_post':
+          console.log('[LinkedInAutomation] Executing comment_post action...');
+          result = await executeCommentPost(this.page, action);
+          console.log('[LinkedInAutomation] comment_post result:', result);
+          break;
+        case 'get_messages':
+          console.log('[LinkedInAutomation] Executing get_messages action...');
+          result = await executeGetMessages(this.page, action);
+          console.log('[LinkedInAutomation] get_messages result:', result);
+          break;
+        case 'check_connection_status':
+          console.log('[LinkedInAutomation] Executing check_connection_status action...');
+          result = await executeCheckConnectionStatus(this.page, action);
+          console.log('[LinkedInAutomation] check_connection_status result:', result);
+          break;
+        case 'get_linkedin_search_results':
+          console.log('[LinkedInAutomation] Executing get_linkedin_search_results action...');
+          result = await executeLinkedInSearch(this.page, action);
+          console.log('[LinkedInAutomation] get_linkedin_search_results result:', result);
+          break;
+        case 'get_daily_linkedin_connections':
+          console.log('[LinkedInAutomation] Executing get_daily_linkedin_connections action...');
+          result = await executeGetDailyLinkedInConnections(this.page, action);
+          console.log('[LinkedInAutomation] get_daily_linkedin_connections result:', result);
+          break;
+        case 'get_new_messages':
+          console.log('[LinkedInAutomation] Executing get_new_messages action...');
+          result = await executeGetNewMessages(this.page, action, this.getAccessToken());
+          console.log('[LinkedInAutomation] get_new_messages result:', result);
+          break;
+        case 'get_linkedin_updates':
+          console.log('[LinkedInAutomation] Executing get_linkedin_updates action...');
+          result = await executeGetLinkedInUpdates(this.page, action, this.getAccessToken());
+          console.log('[LinkedInAutomation] get_linkedin_updates result:', result);
+          break;
+        default:
+          console.log('[LinkedInAutomation] Unknown action type:', action.action);
+          result = { error: `Unknown action type: ${action.action}` };
+      }
+
+      console.log('[LinkedInAutomation] Reporting action result for ID:', action.action_id);
+      await this.reportActionResult(action.action_id, result);
+      console.log('[LinkedInAutomation] Action completed successfully:', action.action);
+      
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error executing action:', action.action, 'Error:', error.message);
+      await this.reportActionResult(action.action_id, { error: error.message });
+    }
+    
+    this.currentAction = null;
+    this.emitActionUpdate();
+  }
+
+
+  async reportActionResult(actionId, result) {
+    try {
+      console.log('[LinkedInAutomation] Sending result to backend for action ID:', actionId);
+      console.log('[LinkedInAutomation] Result data:', JSON.stringify(result, null, 2));
+      
+      const idToken = this.getAccessToken();
+      if (!idToken) {
+        console.error('[LinkedInAutomation] No id_token available for reporting result');
+        return;
+      }
+      
+      const response = await fetch('https://api.coffeeinabit.com/app/actions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${idToken}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          action_id: actionId,
+          result: result
+        })
+      });
+      
+      if (response.ok) {
+        const responseData = await response.json();
+        console.log('[LinkedInAutomation] Successfully reported action result. Response:', responseData);
+      } else {
+        console.error('[LinkedInAutomation] Failed to report action result. Status:', response.status);
+        const errorText = await response.text();
+        console.error('[LinkedInAutomation] Error response:', errorText);
+      }
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error reporting action result:', error);
+    }
+  }
+
+  getAccessToken() {
+    return this._currentAccessToken || null;
+  }
+
+  async launchBrowserAndLogin() {
+    console.log('[LinkedInAutomation] Launching Firefox for LinkedIn login...');
+    
+    this.browser = await firefox.launch({ headless: this.headless || false });
+
+    this.context = await this.browser.newContext({
+      viewport: null,
+      ignoreHTTPSErrors: true
+    });
+
+    await this.enablePerformanceMode();
+    this.page = await this.context.newPage();
+
+    const sessionLoaded = await this.loadLinkedInSession();
+    
+    if (sessionLoaded) {
+      console.log('[LinkedInAutomation] Saved session loaded, checking if still authenticated...');
+      await this.checkAndVerifySession();
+    } else {
+      console.log('[LinkedInAutomation] No saved session, starting fresh login...');
+      await this.startLinkedInLogin();
+    }
+  }
+
+  async checkAndVerifySession() {
+    try {
+      console.log('[LinkedInAutomation] Navigating to LinkedIn feed to verify session...');
+      await this.page.goto('https://www.linkedin.com/feed/', { 
+        waitUntil: 'domcontentloaded',
+        timeout: 30000
+      });
+
+      await this.restoreLocalStorage();
+
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      let verifyAttempts = 0;
+      const maxVerifyAttempts = 3;
+
+      while (verifyAttempts < maxVerifyAttempts) {
+        await this.updatePageInfo();
+        console.log(`[LinkedInAutomation] Verification attempt ${verifyAttempts + 1}/${maxVerifyAttempts}, URL: ${this.currentUrl}`);
+
+        if (this.currentUrl.includes('/feed')) {
+          console.log('[LinkedInAutomation] Session verified! Already logged in.');
+          this.status = 'linkedin_logged_in';
+          this.emitStatus();
+          
+          console.log('[LinkedInAutomation] Starting action polling...');
+          this.startActionPolling();
+          return true;
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        verifyAttempts++;
+      }
+
+      console.log('[LinkedInAutomation] Session verification failed - redirected to login. Starting fresh login...');
+      await this.startLinkedInLogin();
+      return false;
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error verifying session:', error);
+      console.log('[LinkedInAutomation] Falling back to fresh login...');
+      await this.startLinkedInLogin();
+      return false;
+    }
+  }
+
+  async enablePerformanceMode() {
+    if (!this.context) return;
+    
+    console.log('[LinkedInAutomation] Setting increased timeouts for better reliability...');
+    this.context.setDefaultNavigationTimeout(90000);
+    this.context.setDefaultTimeout(60000);
+  }
+
+
+  getStatus() {
+    return {
+      status: this.status,
+      isRunning: this.isRunning,
+      currentUrl: this.currentUrl,
+      title: this.title,
+      timestamp: new Date().toISOString()
+    };
+  }
+}