coffeeinabit 0.0.52 → 0.0.54

package/helpers/auto_start.js

@@ -129,10 +129,22 @@ async function tryFileBasedAutoStart(contextDir, cloudAuth, linkedinAutomation)
  */
 export async function tryStartAutomationWithSession(sessionData, cloudAuth, linkedinAutomation) {
   try {
+    const newUserEmail = sessionData.user?.email || 'default_user';
+    
     // Check if automation is already running
     if (linkedinAutomation.isRunning) {
-      console.log('[AutoStart] Automation is already running, skipping auto-start');
-      return false;
+      // If running for the same user, skip (already running)
+      if (linkedinAutomation._currentUserEmail === newUserEmail) {
+        console.log('[AutoStart] Automation is already running for this user, skipping auto-start');
+        return false;
+      }
+      // If running for a different user, stop it first
+      console.log(`[AutoStart] Automation running for different user (${linkedinAutomation._currentUserEmail}), stopping...`);
+      try {
+        await linkedinAutomation.stopAutomation();
+      } catch (err) {
+        console.error('[AutoStart] Error stopping previous automation:', err.message);
+      }
     }
 
     // Create a session-like object that works with cloudAuth methods

package/linkedin_automation.js

@@ -14,6 +14,8 @@ import { executeGetMessages, closeAllConversationBubbles } from './tools/get_mes
 import { executeLinkedInSearch } from './tools/get_linkedin_search_results.js';
 import { executeGetNewMessages } from './tools/get_new_messages.js';
 import { executeGetLinkedInUpdates } from './tools/get_linkedin_updates.js';
+import { executeGetNewEngagers } from './tools/get_new_engagers.js';
+import { executeGetMessageThreads } from './tools/get_message_threads.js';
 import { safeGoto } from './tools/navigation.js';
 import { humanLikeAmbientMove, resetHumanMouseState } from './tools/human_mouse.js';
 import { logger } from './helpers/logger.js';
@@ -149,19 +151,24 @@ export class LinkedInAutomation {
     if (this.hasActiveBrowser()) {
       return true;
     }
-    this.handleBrowserUnavailable(context);
+    // Only call handleBrowserUnavailable if not already in that state
+    if (this.status !== 'browser_unavailable') {
+      this.handleBrowserUnavailable(context);
+    }
     return false;
   }
 
   handleBrowserUnavailable(context) {
+    // Only log and stop once - avoid spam when multiple intervals detect browser gone
+    if (this.status === 'browser_unavailable') {
+      return; // Already handled
+    }
     logger.warn(`[LinkedInAutomation] Browser unavailable during ${context}. Stopping background activities...`);
+    this.status = 'browser_unavailable';
     this.stopActionPolling();
     this.stopScreenshotCapture();
     this.stopAmbientMouseMovements();
-    if (this.status !== 'browser_unavailable') {
-      this.status = 'browser_unavailable';
-      this.emitStatus();
-    }
+    this.emitStatus();
   }
 
   getLinkedInSessionPath() {
@@ -298,8 +305,17 @@ export class LinkedInAutomation {
 
   async startAutomation(headless = true) {
     try {
+      // Don't restart if already running or in authenticating phase (user trying to login)
+      if (this.hasActiveBrowser() &&
+          (this.currentPhase === this.PHASE_AUTHENTICATING ||
+           this.currentPhase === this.PHASE_AUTHENTICATED ||
+           this.currentPhase === this.PHASE_RUNNING)) {
+        logger.log(`[LinkedInAutomation] Browser already active in phase ${this.currentPhase}, skipping restart`);
+        return;
+      }
+
       logger.log('[LinkedInAutomation] Starting automation...');
-      
+
       // Reset authentication promise
       this.authenticationPromise = new Promise((resolve, reject) => {
         this.authenticationResolve = resolve;
@@ -397,9 +413,9 @@ export class LinkedInAutomation {
         this.needsManualLogin = true;
         this.status = 'manual_login_needed';
         this.emitStatus();
-        
+
         await this.closeBrowser();
-        
+
         this.headless = false;
         await this.launchBrowserAndLogin();
         
@@ -448,8 +464,9 @@ export class LinkedInAutomation {
 
       const pollInterval = setInterval(async () => {
         try {
-          if (!this.page || !this.isRunning) {
-            logger.log('[LinkedInAutomation] Login polling stopped - page:', !!this.page, 'isRunning:', this.isRunning);
+          // Only check if page exists, not isRunning (since isRunning is false during authentication)
+          if (!this.page) {
+            logger.log('[LinkedInAutomation] Login polling stopped - no page available');
             clearInterval(pollInterval);
             return;
           }
@@ -474,28 +491,22 @@ export class LinkedInAutomation {
             const secondCheck = this.page.url();
             if (secondCheck.includes('/feed')) {
               logger.log('[LinkedInAutomation] Second check confirmed - still on /feed/');
-              
+
               logger.log('[LinkedInAutomation] Session will be persisted automatically by launchPersistentContext...');
-              
+
+              // Also save cookies explicitly for redundancy
+              logger.log('[LinkedInAutomation] Saving cookies explicitly after successful login...');
+              await this.saveLinkedInSession();
+
               this.status = 'linkedin_logged_in';
               this.emitStatus();
               
               if (this.originalHeadless && this.needsManualLogin) {
-                logger.log('[LinkedInAutomation] Manual login completed. Waiting for session to be saved...');
+                logger.log('[LinkedInAutomation] Manual login completed. Waiting for session to persist...');
                 clearInterval(pollInterval);
-                
+
                 await this.waitRandom(5000, 7000);
                 
-                const storageStatePath = this.getStorageStatePath();
-                try {
-                  await this.context.storageState({ path: storageStatePath });
-                  const cookies = await this.context.cookies();
-                  logger.log(`[LinkedInAutomation] Saved storage state with ${cookies.length} cookies to: ${storageStatePath}`);
-                } catch (error) {
-                  logger.error('[LinkedInAutomation] Error saving storage state:', error.message);
-                }
-                await this.waitRandom(3000, 5000);
-                
                 logger.log('[LinkedInAutomation] Switching back to headless mode...');
                 this.status = 'switching_to_headless';
                 this.emitStatus();
@@ -547,52 +558,75 @@ export class LinkedInAutomation {
     try {
       logger.log('[LinkedInAutomation] Closing browser...');
       this.stopAmbientMouseMovements();
-      
+
       if (this.page) {
-        await this.page.close();
+        try {
+          await this.page.close();
+        } catch (e) {
+          logger.warn('[LinkedInAutomation] Page already closed:', e.message);
+        }
         this.page = null;
       }
 
       if (this.context) {
+        // Persistent context auto-saves cookies to userDataPath on close.
+        // No need to save a separate storage state file.
         try {
-          const storageStatePath = this.getStorageStatePath();
-          const cookies = await this.context.cookies();
-          if (cookies.length > 0) {
-            await this.context.storageState({ path: storageStatePath });
-            logger.log(`[LinkedInAutomation] Saved storage state with ${cookies.length} cookies to: ${storageStatePath}`);
-          }
           await this.context.close();
           await this.waitRandom(3000, 5000);
         } catch (error) {
-          logger.error('[LinkedInAutomation] Error saving storage state before close:', error.message);
-          try {
-            await this.context.close();
-            await this.waitRandom(3000, 5000);
-          } catch (closeError) {
-            logger.error('[LinkedInAutomation] Error closing context:', closeError.message);
-          }
+          logger.error('[LinkedInAutomation] Error closing context:', error.message);
         }
         this.context = null;
         this.browser = null;
       }
 
+      // Clean up stale Chromium lock files from the user data directory.
+      // If a previous Chromium process was killed (OOM, SIGTRAP, etc.), these
+      // symlinks remain and prevent a new instance from launching.
+      this._cleanupBrowserLockFiles();
+
       logger.log('[LinkedInAutomation] Browser closed successfully');
     } catch (error) {
       logger.error('[LinkedInAutomation] Error closing browser:', error);
     }
   }
 
+  _cleanupBrowserLockFiles() {
+    try {
+      const sanitizedEmail = (this.userEmail || 'default_user').replace(/[^a-zA-Z0-9]/g, '_');
+      const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
+      const lockFiles = ['SingletonLock', 'SingletonSocket', 'SingletonCookie'];
+      for (const lockFile of lockFiles) {
+        const lockPath = path.join(userDataPath, lockFile);
+        if (fs.existsSync(lockPath)) {
+          fs.unlinkSync(lockPath);
+          logger.log(`[LinkedInAutomation] Removed stale lock file: ${lockFile}`);
+        }
+      }
+    } catch (error) {
+      logger.warn('[LinkedInAutomation] Error cleaning up lock files:', error.message);
+    }
+  }
+
   async stopAutomation() {
     try {
       logger.log('[LinkedInAutomation] Stopping automation...');
       this.transitionToPhase(this.PHASE_STOPPING);
       this.isRunning = false;
 
-      // Reject any pending authentication promises
+      // Reject any pending authentication promises (defer so stop route can complete first)
       if (this.authenticationReject) {
-        this.authenticationReject(new Error('Automation stopped'));
+        const reject = this.authenticationReject;
         this.authenticationResolve = null;
         this.authenticationReject = null;
+        setImmediate(() => {
+          try {
+            reject(new Error('Automation stopped'));
+          } catch (_) {
+            // Consumer may have already settled; ignore
+          }
+        });
       }
 
       this.stopScreenshotCapture();
@@ -701,11 +735,19 @@ export class LinkedInAutomation {
     let currentInterval = this.pollIntervalMs;
 
     const pollWithBackoff = async () => {
+      // Check if polling should continue
       if (!this.isActionPollingActive) {
         logger.log('[LinkedInAutomation] Action polling stopped, not scheduling next poll');
         return;
       }
 
+      // Check if browser is still available before polling
+      if (!this.hasActiveBrowser()) {
+        logger.log('[LinkedInAutomation] Browser unavailable, stopping action polling loop');
+        this.isActionPollingActive = false;
+        return;
+      }
+
       if (this.currentAction) {
         logger.log('[LinkedInAutomation] Action in progress, skipping polling...');
         logger.log('[LinkedInAutomation] Next poll in', Math.round(currentInterval / 1000), 'seconds');
@@ -716,6 +758,13 @@ export class LinkedInAutomation {
       // pollForActions now returns true if actions were found and processed
       const foundActions = await this.pollForActions();
 
+      // Re-check after potentially long-running action execution (which includes task polling)
+      if (!this.isActionPollingActive || !this.hasActiveBrowser()) {
+        logger.log('[LinkedInAutomation] Polling stopped or browser closed during action, not scheduling next poll');
+        this.isActionPollingActive = false;
+        return;
+      }
+
       if (foundActions) {
         // reset backoff when we processed work
         currentInterval = this.pollIntervalMs;
@@ -733,6 +782,9 @@ export class LinkedInAutomation {
   }
 
   stopActionPolling() {
+    if (!this.isActionPollingActive) {
+      return; // Already stopped
+    }
     logger.log('[LinkedInAutomation] Action polling stopped');
     this.isActionPollingActive = false;
   }
@@ -956,7 +1008,14 @@ export class LinkedInAutomation {
       this.emitStatus();
       
       let result = null;
-      
+
+      // Normalize: if no username in parameters, use linkedin_profile_id from action
+      if (!action.parameters?.username && action.linkedin_profile_id) {
+        action.parameters = action.parameters || {};
+        action.parameters.username = action.linkedin_profile_id;
+        logger.log('[LinkedInAutomation] Set username from linkedin_profile_id:', action.linkedin_profile_id);
+      }
+
       // add esc to close any modals that might interfere
       await this.page.keyboard.press('Escape');
       await this.waitRandom(100, 2000);
@@ -998,6 +1057,14 @@ export class LinkedInAutomation {
           logger.log('[LinkedInAutomation] Executing get_linkedin_updates action...');
           result = await executeGetLinkedInUpdates(this.page, action, await this.getAccessToken());
           break;
+        case 'get_new_engagers':
+          logger.log('[LinkedInAutomation] Executing get_new_engagers action...');
+          result = await executeGetNewEngagers(this.page, action);
+          break;
+        case 'get_message_threads':
+          logger.log('[LinkedInAutomation] Executing get_message_threads action...');
+          result = await executeGetMessageThreads(this.page, action);
+          break;
         default:
           logger.log('[LinkedInAutomation] Unknown action type:', action.action);
           result = { error: `Unknown action type: ${action.action}` };
@@ -1316,14 +1383,51 @@ export class LinkedInAutomation {
     return path.join(this.linkedInSessionDir, `storage_state_${sanitizedEmail}.json`);
   }
 
+  async clearCookies() {
+    const email = this._currentUserEmail || this.userEmail || 'default_user';
+    const sanitizedEmail = email.replace(/[^a-zA-Z0-9]/g, '_');
+    const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
+    const storageStatePath = this.getStorageStatePath();
+
+    // Stop automation if running
+    if (this.isRunning) {
+      logger.log('[LinkedInAutomation] Stopping automation before clearing cookies...');
+      await this.stopAutomation();
+    }
+
+    // Delete the persistent context user data directory
+    if (fs.existsSync(userDataPath)) {
+      fs.rmSync(userDataPath, { recursive: true, force: true });
+      logger.log(`[LinkedInAutomation] Deleted user data directory: ${userDataPath}`);
+    }
+
+    // Delete the storage state file if it exists
+    if (fs.existsSync(storageStatePath)) {
+      fs.unlinkSync(storageStatePath);
+      logger.log(`[LinkedInAutomation] Deleted storage state file: ${storageStatePath}`);
+    }
+
+    logger.log(`[LinkedInAutomation] All cookies cleared for ${email}`);
+  }
+
   async launchBrowserAndLogin() {
     logger.log('[LinkedInAutomation] Launching Chromium with persistent context for LinkedIn login...');
     
+    // Close any existing browser BEFORE updating userEmail (so cookies save to correct user's file)
+    if (this.context || this.browser) {
+      logger.log(`[LinkedInAutomation] Existing browser detected for user ${this.userEmail}, closing before re-launch...`);
+      await this.closeBrowser();  // Uses old this.userEmail for storage path
+    }
+    
+    // Now safe to update userEmail to the new user
+    const previousUserEmail = this.userEmail;
     this.userEmail = this._currentUserEmail || 'default_user';
+    if (previousUserEmail && previousUserEmail !== this.userEmail && previousUserEmail !== 'default_user') {
+      logger.log(`[LinkedInAutomation] User switched: ${previousUserEmail} -> ${this.userEmail}`);
+    }
     const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
     const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
-    const storageStatePath = this.getStorageStatePath();
-    
+
     logger.log('[LinkedInAutomation] User data path:', userDataPath);
 
     if (!fs.existsSync(userDataPath)) {
@@ -1331,6 +1435,9 @@ export class LinkedInAutomation {
       logger.log('[LinkedInAutomation] Created user data directory:', userDataPath);
     }
 
+    // Clean up stale lock files before launching (from previous crashes/OOM kills)
+    this._cleanupBrowserLockFiles();
+
     const launchOptions = {
       headless: this.headless || false,
       viewport: (this.headless || false) ? { width: 1920, height: 1080 } : null,
@@ -1352,21 +1459,23 @@ export class LinkedInAutomation {
     await this.enablePerformanceMode();
     await this.preparePrimaryPage();
     
-    if (fs.existsSync(storageStatePath)) {
-      try {
-        logger.log('[LinkedInAutomation] Loading cookies from storage state file:', storageStatePath);
-        const storageState = JSON.parse(fs.readFileSync(storageStatePath, 'utf8'));
-        if (storageState.cookies && storageState.cookies.length > 0) {
-          await this.context.addCookies(storageState.cookies);
-          logger.log(`[LinkedInAutomation] Added ${storageState.cookies.length} cookies from storage state file`);
-        }
-      } catch (error) {
-        logger.error('[LinkedInAutomation] Error loading storage state:', error.message);
+    // Persistent context already manages its own cookies via userDataPath.
+    // Do NOT load extra cookies from storage state file — it causes mixing/conflicts.
+
+    const cookiesAfterLaunch = await this.context.cookies();
+    logger.log(`[LinkedInAutomation] Total ${cookiesAfterLaunch.length} cookies in persistent context`);
+
+    // If persistent context has no/few cookies, try loading from JSON backup
+    if (cookiesAfterLaunch.length < 5) {
+      logger.log('[LinkedInAutomation] Persistent context has few/no cookies, attempting to load from JSON backup...');
+      const loaded = await this.loadLinkedInSession();
+      if (loaded) {
+        const cookiesAfterLoad = await this.context.cookies();
+        logger.log(`[LinkedInAutomation] Loaded cookies from JSON backup, now have ${cookiesAfterLoad.length} cookies`);
+      } else {
+        logger.log('[LinkedInAutomation] No JSON backup found or failed to load');
       }
     }
-    
-    const cookiesAfterLaunch = await this.context.cookies();
-    logger.log(`[LinkedInAutomation] Total ${cookiesAfterLaunch.length} cookies in context`);
 
     // await this.installCursorHighlight();
 
@@ -1433,21 +1542,13 @@ export class LinkedInAutomation {
       const currentTitle = await this.page.title();
       const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
       const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
-      
-      const storageStatePath = this.getStorageStatePath();
-      try {
-        await this.context.storageState({ path: storageStatePath });
-        const cookies = await this.context.cookies();
-        logger.log(`[LinkedInAutomation] Saved storage state with ${cookies.length} cookies before mode switch`);
-      } catch (error) {
-        logger.error('[LinkedInAutomation] Error saving storage state:', error);
-      }
-      
+
+      // Persistent context auto-saves cookies to userDataPath on close.
       await this.context.close();
       await this.waitRandom(3000, 5000);
-      
+
       this.headless = newHeadless;
-      
+
       const launchOptions = {
         headless: this.headless,
         viewport: null,
@@ -1459,20 +1560,8 @@ export class LinkedInAutomation {
           '--disable-setuid-sandbox'
         ]
       };
-      
+
       this.context = await chromium.launchPersistentContext(userDataPath, launchOptions);
-      
-      if (fs.existsSync(storageStatePath)) {
-        try {
-          const storageState = JSON.parse(fs.readFileSync(storageStatePath, 'utf8'));
-          if (storageState.cookies && storageState.cookies.length > 0) {
-            await this.context.addCookies(storageState.cookies);
-            logger.log(`[LinkedInAutomation] Added ${storageState.cookies.length} cookies from storage state for mode switch`);
-          }
-        } catch (error) {
-          logger.error('[LinkedInAutomation] Error loading storage state for mode switch:', error.message);
-        }
-      }
 
       this.browser = this.context;
 
@@ -1539,13 +1628,11 @@ export class LinkedInAutomation {
         verifyAttempts++;
       }
 
-      logger.log('[LinkedInAutomation] Session verification failed - redirected to login. Starting fresh login...');
-      await this.startLinkedInLogin();
+      logger.log('[LinkedInAutomation] Session verification failed - redirected to login.');
       return false;
     } catch (error) {
       logger.error('[LinkedInAutomation] Error verifying session:', error);
-      logger.log('[LinkedInAutomation] Falling back to fresh login...');
-      await this.startLinkedInLogin();
+      logger.log('[LinkedInAutomation] Session check failed, will need fresh login.');
       return false;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "coffeeinabit app",
   "main": "server.js",
   "type": "module",