coffeeinabit 0.0.46 → 0.0.48

package/helpers/version_check.js

@@ -0,0 +1,172 @@
+import axios from 'axios';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const execAsync = promisify(exec);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Version Check Helper
+ * 
+ * Checks npm registry for newer version and automatically installs it if available.
+ */
+
+/**
+ * Get current version from package.json
+ * @returns {string} Current version
+ */
+function getCurrentVersion() {
+  try {
+    const packagePath = join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+    return packageJson.version;
+  } catch (error) {
+    console.error('[VersionCheck] Error reading package.json:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Query npm registry for latest version
+ * @param {string} packageName - Package name to check
+ * @returns {Promise<string|null>} Latest version or null if error
+ */
+async function getLatestVersion(packageName) {
+  try {
+    const registryUrl = `https://registry.npmjs.org/${packageName}/latest`;
+    const response = await axios.get(registryUrl, {
+      timeout: 5000,
+      headers: {
+        'Accept': 'application/json'
+      }
+    });
+    return response.data.version;
+  } catch (error) {
+    console.error('[VersionCheck] Error querying npm registry:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} current - Current version
+ * @param {string} latest - Latest version
+ * @returns {boolean} True if latest is newer than current
+ */
+function isNewerVersion(current, latest) {
+  if (!current || !latest) return false;
+  
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+  
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const currentPart = currentParts[i] || 0;
+    const latestPart = latestParts[i] || 0;
+    
+    if (latestPart > currentPart) return true;
+    if (latestPart < currentPart) return false;
+  }
+  
+  return false;
+}
+
+/**
+ * Install the latest version globally
+ * @param {string} packageName - Package name to install
+ * @returns {Promise<boolean>} True if installation succeeded
+ */
+async function installLatestVersion(packageName) {
+  try {
+    console.log(`[VersionCheck] Installing ${packageName}@latest...`);
+    const { stdout, stderr } = await execAsync(`npm install -g ${packageName}@latest`, {
+      timeout: 120000 // 2 minutes timeout
+    });
+    
+    if (stderr && !stderr.includes('npm WARN')) {
+      console.error('[VersionCheck] Installation warnings:', stderr);
+    }
+    
+    console.log('[VersionCheck] ✅ Successfully installed latest version');
+    console.log('[VersionCheck] Please restart the application to use the new version');
+    return true;
+  } catch (error) {
+    console.error('[VersionCheck] ❌ Failed to install latest version:', error.message);
+    if (error.stdout) console.log('[VersionCheck] stdout:', error.stdout);
+    if (error.stderr) console.error('[VersionCheck] stderr:', error.stderr);
+    return false;
+  }
+}
+
+/**
+ * Check for updates and install if newer version is available
+ * @param {string} packageName - Package name to check (default: 'coffeeinabit')
+ * @param {boolean} autoInstall - Whether to automatically install (default: true)
+ * @returns {Promise<object>} Update check result
+ */
+export async function checkAndUpdateVersion(packageName = 'coffeeinabit', autoInstall = true) {
+  try {
+    console.log('[VersionCheck] Checking for updates...');
+    
+    const currentVersion = getCurrentVersion();
+    if (!currentVersion) {
+      return {
+        success: false,
+        error: 'Could not read current version'
+      };
+    }
+    
+    console.log(`[VersionCheck] Current version: ${currentVersion}`);
+    
+    const latestVersion = await getLatestVersion(packageName);
+    if (!latestVersion) {
+      return {
+        success: false,
+        error: 'Could not query npm registry'
+      };
+    }
+    
+    console.log(`[VersionCheck] Latest version: ${latestVersion}`);
+    
+    if (!isNewerVersion(currentVersion, latestVersion)) {
+      console.log('[VersionCheck] ✅ You are running the latest version');
+      return {
+        success: true,
+        currentVersion,
+        latestVersion,
+        updateAvailable: false
+      };
+    }
+    
+    console.log(`[VersionCheck] ⚠️  New version available: ${latestVersion} (current: ${currentVersion})`);
+    
+    if (autoInstall) {
+      const installed = await installLatestVersion(packageName);
+      return {
+        success: installed,
+        currentVersion,
+        latestVersion,
+        updateAvailable: true,
+        installed
+      };
+    }
+    
+    return {
+      success: true,
+      currentVersion,
+      latestVersion,
+      updateAvailable: true,
+      installed: false
+    };
+  } catch (error) {
+    console.error('[VersionCheck] Error during version check:', error.message);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}

package/linkedin_automation.js

@@ -12,7 +12,6 @@ import { executeSendMessages } from './tools/send_messages.js';
 import { executeCommentPost } from './tools/comment_post.js';
 import { executeGetMessages, closeAllConversationBubbles } from './tools/get_messages.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';
 import { safeGoto } from './tools/navigation.js';
@@ -42,6 +41,16 @@ export class LinkedInAutomation {
     this.ambientMouseTimeout = null;
     this.cloudAuth = new CloudAuth();
     this._currentRefreshToken = null;
+    this._currentAccessToken = null; // Track access token explicitly
+    
+    // Authentication failure tracking
+    this.consecutiveAuthFailures = 0;
+    this.maxAuthFailures = 3; // Stop polling after 3 consecutive failures
+    this.authFailurePaused = false;
+    this.lastAuthFailureTime = null;
+    
+    // Token re-sync callback (set externally if available)
+    this.tokenResyncCallback = null;
     
     // Lifecycle phases
     this.PHASE_IDLE = 'idle';
@@ -730,13 +739,43 @@ export class LinkedInAutomation {
     if (!this.ensureBrowserAvailable('pollForActions')) {
       return;
     }
+
+    // Check if polling is paused due to auth failures
+    if (this.authFailurePaused) {
+      console.log('[LinkedInAutomation] Polling paused due to authentication failures. Attempting recovery...');
+      
+      // Try to re-sync tokens and recover
+      const idToken = await this.getAccessToken();
+      if (idToken && !this.cloudAuth.isTokenExpired(idToken)) {
+        console.log('[LinkedInAutomation] Authentication recovered, resuming polling');
+        this.authFailurePaused = false;
+        this.consecutiveAuthFailures = 0;
+        // Continue with normal polling below
+      } else {
+        console.log('[LinkedInAutomation] Still unable to authenticate, skipping poll');
+        
+        // Emit event to notify UI
+        if (this.io) {
+          this.io.emit('automation:auth-failure', {
+            message: 'Authentication failed. Please re-authenticate.',
+            paused: true,
+            consecutiveFailures: this.consecutiveAuthFailures,
+            lastFailureTime: this.lastAuthFailureTime
+          });
+        }
+        
+        return false;
+      }
+    }
+
     try {
       console.log('[LinkedInAutomation] Polling for actions from backend...');
       
       const idToken = await this.getAccessToken();
       if (!idToken) {
         console.error('[LinkedInAutomation] No id_token available for authentication');
-        return;
+        this.handleAuthFailure('No token available');
+        return false;
       }
       
       console.log('[LinkedInAutomation] Using id_token for authentication:', idToken.substring(0, 20) + '...');
@@ -760,25 +799,116 @@ export class LinkedInAutomation {
           for (const action of actions) {
             await this.executeAction(action);
           }
+          // Reset failure counter on successful request
+          this.consecutiveAuthFailures = 0;
+          this.authFailurePaused = false;
           // Indicate there was work
           return true;
         } else {
           console.log('[LinkedInAutomation] No actions to execute, continuing to poll...');
+          // Reset failure counter on successful request (even with no actions)
+          this.consecutiveAuthFailures = 0;
+          this.authFailurePaused = false;
           return false;
         }
+      } else if (response.status === 401) {
+        // Handle 401 Unauthorized specifically
+        const errorText = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.message || 'Unauthorized';
+        } catch {
+          errorMessage = errorText || 'Unauthorized';
+        }
+        
+        console.error('[LinkedInAutomation] Authentication failed (401 Unauthorized):', errorMessage);
+        
+        // Clear current token since it's invalid
+        this._currentAccessToken = null;
+        
+        // Try to re-sync tokens one more time
+        console.log('[LinkedInAutomation] Attempting token re-sync after 401 error...');
+        const resynced = await this.attemptTokenResync();
+        
+        if (!resynced) {
+          this.handleAuthFailure(`401 Unauthorized: ${errorMessage}`);
+        } else {
+          // If re-sync worked, try to refresh the token
+          if (this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
+            const refreshResult = await this.cloudAuth.refreshTokens(this._currentRefreshToken);
+            if (!refreshResult.success) {
+              this.handleAuthFailure(`401 Unauthorized: Token re-sync succeeded but refresh failed`);
+            } else {
+              this._currentAccessToken = refreshResult.tokens.idToken;
+              if (refreshResult.tokens.refreshToken) {
+                this._currentRefreshToken = refreshResult.tokens.refreshToken;
+              }
+              console.log('[LinkedInAutomation] Token re-sync and refresh succeeded after 401, resetting failure counter');
+              this.consecutiveAuthFailures = 0;
+              this.authFailurePaused = false;
+            }
+          } else {
+            console.log('[LinkedInAutomation] Token re-sync succeeded after 401, resetting failure counter');
+            this.consecutiveAuthFailures = 0;
+            this.authFailurePaused = false;
+          }
+        }
+        
+        return false;
       } else {
         console.error('[LinkedInAutomation] Failed to fetch actions. Status:', response.status, response.statusText);
         const errorText = await response.text();
         console.error('[LinkedInAutomation] Error response:', errorText);
+        // Non-auth errors don't count as auth failures
         return false;
       }
     } catch (error) {
       console.error('[LinkedInAutomation] Error polling for actions:', error.message);
       console.error('[LinkedInAutomation] Full error:', error);
+      
+      // Check if error is auth-related
+      if (error.message.includes('401') || error.message.includes('Unauthorized') || error.message.includes('token')) {
+        this.handleAuthFailure(`Network error: ${error.message}`);
+      }
+      
       return false;
     }
   }
 
+  /**
+   * Handle authentication failure - track consecutive failures and pause polling if threshold reached
+   * @param {string} reason - Reason for the auth failure
+   */
+  handleAuthFailure(reason) {
+    this.consecutiveAuthFailures++;
+    this.lastAuthFailureTime = new Date().toISOString();
+    
+    console.warn(`[LinkedInAutomation] Authentication failure #${this.consecutiveAuthFailures}: ${reason}`);
+    
+    if (this.consecutiveAuthFailures >= this.maxAuthFailures) {
+      if (!this.authFailurePaused) {
+        this.authFailurePaused = true;
+        console.error(`[LinkedInAutomation] ⚠️  STOPPING polling after ${this.consecutiveAuthFailures} consecutive authentication failures`);
+        console.error('[LinkedInAutomation] Polling will resume when authentication is restored.');
+        console.error('[LinkedInAutomation] Please re-authenticate or check your session.');
+        
+        // Emit event to notify UI
+        if (this.io) {
+          this.io.emit('automation:auth-failure', {
+            message: `Authentication failed after ${this.consecutiveAuthFailures} attempts. Polling paused.`,
+            paused: true,
+            consecutiveFailures: this.consecutiveAuthFailures,
+            lastFailureTime: this.lastAuthFailureTime,
+            reason: reason
+          });
+        }
+      }
+    } else {
+      console.warn(`[LinkedInAutomation] Will pause polling after ${this.maxAuthFailures - this.consecutiveAuthFailures} more failures`);
+    }
+  }
+
   async executeAction(action) {
     const actionLogs = [];
     const originalConsoleLog = console.log;
@@ -858,10 +988,6 @@ export class LinkedInAutomation {
           console.log('[LinkedInAutomation] Executing get_linkedin_search_results action...');
           result = await executeLinkedInSearch(this.page, action);
           break;
-        case 'get_daily_linkedin_connections':
-          console.log('[LinkedInAutomation] Executing get_daily_linkedin_connections action...');
-          result = await executeGetDailyLinkedInConnections(this.page, action);
-          break;
         case 'get_new_messages':
           console.log('[LinkedInAutomation] Executing get_new_messages action...');
           result = await executeGetNewMessages(this.page, action, await this.getAccessToken());
@@ -1053,11 +1179,64 @@ export class LinkedInAutomation {
     }
   }
 
+  /**
+   * Set a callback function to re-sync tokens from external source (e.g., session store)
+   * @param {Function} callback - Function that returns Promise<{idToken, refreshToken}> or null
+   */
+  setTokenResyncCallback(callback) {
+    this.tokenResyncCallback = callback;
+  }
+
+  /**
+   * Attempt to re-sync tokens from external source (session, etc.)
+   * @returns {Promise<boolean>} true if tokens were successfully re-synced
+   */
+  async attemptTokenResync() {
+    if (!this.tokenResyncCallback) {
+      return false;
+    }
+
+    try {
+      const tokens = await this.tokenResyncCallback();
+      if (tokens && tokens.idToken && tokens.refreshToken) {
+        console.log('[LinkedInAutomation] Tokens re-synced from external source');
+        this._currentAccessToken = tokens.idToken;
+        this._currentRefreshToken = tokens.refreshToken;
+        
+        // If tokens are expired, try to refresh them
+        if (this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
+          console.log('[LinkedInAutomation] Re-synced tokens are expired, attempting refresh...');
+          const result = await this.cloudAuth.refreshTokens(this._currentRefreshToken);
+          if (result.success) {
+            this._currentAccessToken = result.tokens.idToken;
+            if (result.tokens.refreshToken) {
+              this._currentRefreshToken = result.tokens.refreshToken;
+            }
+          } else {
+            console.error('[LinkedInAutomation] Failed to refresh re-synced tokens:', result.error);
+            return false;
+          }
+        }
+        
+        return true;
+      }
+    } catch (error) {
+      console.error('[LinkedInAutomation] Error during token re-sync:', error.message);
+    }
+    
+    return false;
+  }
+
   async getAccessToken() {
-    // Check if token exists
+    // First, try to get current token
     if (!this._currentAccessToken) {
-      console.error('[LinkedInAutomation] No access token available');
-      return null;
+      console.log('[LinkedInAutomation] No access token available, attempting re-sync...');
+      const resynced = await this.attemptTokenResync();
+      if (!resynced) {
+        console.error('[LinkedInAutomation] No access token available and re-sync failed');
+        return null;
+      }
+      // Token was re-synced, continue to validation below
     }
 
     // Check if token is expired or expiring soon (within 5 minutes)
@@ -1066,8 +1245,12 @@ export class LinkedInAutomation {
       
       // Check if refresh token is available
       if (!this._currentRefreshToken) {
-        console.error('[LinkedInAutomation] No refresh token available, cannot refresh');
-        return null;
+        console.log('[LinkedInAutomation] No refresh token available, attempting re-sync...');
+        const resynced = await this.attemptTokenResync();
+        if (!resynced || !this._currentRefreshToken) {
+          console.error('[LinkedInAutomation] No refresh token available and re-sync failed');
+          return null;
+        }
       }
 
       // Attempt to refresh the token
@@ -1081,17 +1264,48 @@ export class LinkedInAutomation {
           if (result.tokens.refreshToken) {
             this._currentRefreshToken = result.tokens.refreshToken;
           }
+          // Reset failure counter on successful refresh
+          this.consecutiveAuthFailures = 0;
+          this.authFailurePaused = false;
           return this._currentAccessToken;
         } else {
           console.error('[LinkedInAutomation] Token refresh failed:', result.error);
+          
+          // Try one more time to re-sync before giving up
+          console.log('[LinkedInAutomation] Attempting token re-sync after refresh failure...');
+          const resynced = await this.attemptTokenResync();
+          if (resynced && !this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
+            console.log('[LinkedInAutomation] Token re-synced successfully after refresh failure');
+            this.consecutiveAuthFailures = 0;
+            this.authFailurePaused = false;
+            return this._currentAccessToken;
+          }
+          
           return null;
         }
       } catch (error) {
         console.error('[LinkedInAutomation] Error during token refresh:', error.message);
+        
+        // Try re-sync one more time
+        const resynced = await this.attemptTokenResync();
+        if (resynced && !this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
+          console.log('[LinkedInAutomation] Token re-synced successfully after refresh error');
+          this.consecutiveAuthFailures = 0;
+          this.authFailurePaused = false;
+          return this._currentAccessToken;
+        }
+        
         return null;
       }
     }
 
+    // Token is valid, reset failure counter
+    if (this.consecutiveAuthFailures > 0) {
+      console.log('[LinkedInAutomation] Authentication recovered, resetting failure counter');
+      this.consecutiveAuthFailures = 0;
+      this.authFailurePaused = false;
+    }
+
     return this._currentAccessToken;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "coffeeinabit app",
   "main": "server.js",
   "type": "module",
@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "axios": "^1.6.0",
+    "coffeeinabit": "^0.0.47",
     "dotenv": "^16.3.1",
     "express": "^4.18.2",
     "express-session": "^1.17.3",

package/server.js

@@ -17,6 +17,7 @@ import { createAuthRoutes } from './routes/auth.js';
 import { createAutomationRoutes, createStateRoutes } from './routes/automation.js';
 import { setupSocketHandlers } from './socket/handlers.js';
 import { tryAutoStartAutomation } from './helpers/auto_start.js';
+import { checkAndUpdateVersion } from './helpers/version_check.js';
 
 dotenv.config();
 
@@ -36,9 +37,53 @@ const appState = new AppState();
 // Legacy single automation instance (for backward compatibility during migration)
 // TODO: Remove after full migration to multi-process state
 const linkedinAutomation = new LinkedInAutomation(io);
-linkedinAutomation.getAccessToken = function() {
-  return this._currentAccessToken || null;
-};
+
+// Set up token re-sync callback for legacy automation instance
+// This allows the automation to re-sync tokens from the session store when they expire
+linkedinAutomation.setTokenResyncCallback(async () => {
+  try {
+    // Try to get tokens from session store for the user
+    if (!linkedinAutomation._currentUserEmail) {
+      return null;
+    }
+
+    // Get all sessions and find one for this user
+    if (typeof sessionStore.all === 'function') {
+      return new Promise((resolve) => {
+        sessionStore.all((err, sessions) => {
+          if (err || !sessions) {
+            resolve(null);
+            return;
+          }
+
+          // Find a session for this user
+          for (const sessionId in sessions) {
+            const session = sessions[sessionId];
+            if (session && session.user && session.user.email === linkedinAutomation._currentUserEmail) {
+              // Ensure tokens are valid
+              cloudAuth.ensureValidToken(session).then(result => {
+                if (result.valid && session.tokens) {
+                  resolve({
+                    idToken: session.tokens.idToken,
+                    refreshToken: session.tokens.refreshToken
+                  });
+                } else {
+                  resolve(null);
+                }
+              }).catch(() => resolve(null));
+              return;
+            }
+          }
+          resolve(null);
+        });
+      });
+    }
+  } catch (error) {
+    console.error('[Server] Error in token re-sync callback:', error.message);
+    return null;
+  }
+  return null;
+});
 
 // Initialize session store
 const FileStoreSession = FileStore(session);
@@ -94,6 +139,9 @@ app.use('/auth', createAuthRoutes(cloudAuth, PORT, appState, linkedinAutomation)
 app.use('/api/automation', createAutomationRoutes(cloudAuth, appState, linkedinAutomation, io));
 app.use('/api/state', createStateRoutes(cloudAuth, appState));
 
+// Set up token re-sync dependencies for AppState
+appState.setTokenResyncDependencies(cloudAuth, sessionStore);
+
 // Setup WebSocket handlers
 setupSocketHandlers(io, appState);
 
@@ -104,6 +152,11 @@ server.listen(PORT, async () => {
   console.log(' Press Ctrl+C to stop');
   console.log('');
   
+  // Check for updates on startup (non-blocking)
+  checkAndUpdateVersion('coffeeinabit', true).catch(err => {
+    console.error('[Server] Version check failed:', err.message);
+  });
+  
   // Wait a bit for everything to initialize, then try to auto-start automation
   setTimeout(() => {
     tryAutoStartAutomation(sessionStore, contextDir, cloudAuth, linkedinAutomation);

package/state/app_state.js

@@ -18,6 +18,10 @@ export class AppState {
     // Private state: Map of socketId -> process state
     this._processes = new Map();
     
+    // Dependencies for token re-sync (set externally)
+    this._cloudAuth = null;
+    this._sessionStore = null;
+    
     // Statistics
     this._stats = {
       totalProcessesCreated: 0,
@@ -26,6 +30,16 @@ export class AppState {
     };
   }
 
+  /**
+   * Set dependencies for token re-sync
+   * @param {object} cloudAuth - CloudAuth instance
+   * @param {object} sessionStore - Session store instance
+   */
+  setTokenResyncDependencies(cloudAuth, sessionStore) {
+    this._cloudAuth = cloudAuth;
+    this._sessionStore = sessionStore;
+  }
+
   /**
    * Create a new automation process for a socket connection
    * @param {string} socketId - WebSocket connection ID
@@ -40,9 +54,54 @@ export class AppState {
     }
 
     const automation = new LinkedInAutomation(io);
-    automation.getAccessToken = function() {
-      return this._currentAccessToken || null;
-    };
+    
+    // Set up token re-sync callback if dependencies are available
+    if (this._cloudAuth && this._sessionStore) {
+      const userEmail = session?.user?.email;
+      automation.setTokenResyncCallback(async () => {
+        try {
+          if (!userEmail) {
+            return null;
+          }
+
+          // Try to get tokens from session store for this user
+          if (typeof this._sessionStore.all === 'function') {
+            return new Promise((resolve) => {
+              this._sessionStore.all((err, sessions) => {
+                if (err || !sessions) {
+                  resolve(null);
+                  return;
+                }
+
+                // Find a session for this user
+                for (const sessionId in sessions) {
+                  const sess = sessions[sessionId];
+                  if (sess && sess.user && sess.user.email === userEmail) {
+                    // Ensure tokens are valid
+                    this._cloudAuth.ensureValidToken(sess).then(result => {
+                      if (result.valid && sess.tokens) {
+                        resolve({
+                          idToken: sess.tokens.idToken,
+                          refreshToken: sess.tokens.refreshToken
+                        });
+                      } else {
+                        resolve(null);
+                      }
+                    }).catch(() => resolve(null));
+                    return;
+                  }
+                }
+                resolve(null);
+              });
+            });
+          }
+        } catch (error) {
+          console.error('[AppState] Error in token re-sync callback:', error.message);
+          return null;
+        }
+        return null;
+      });
+    }
 
     const processState = {
       socketId,