coffeeinabit 0.0.45 → 0.0.47

package/helpers/auto_start.js

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Auto-Start Helper
+ * 
+ * Handles automatic startup of LinkedIn automation when the server starts
+ * if there are existing authenticated sessions.
+ */
+
+/**
+ * Attempt to automatically start automation if user is authenticated
+ * Note: Auto-start uses legacy single instance for backward compatibility.
+ * New implementations should wait for WebSocket connections.
+ * 
+ * @param {object} sessionStore - Express session store
+ * @param {string} contextDir - Context directory path
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} linkedinAutomation - LinkedInAutomation instance
+ */
+export async function tryAutoStartAutomation(sessionStore, contextDir, cloudAuth, linkedinAutomation) {
+  try {
+    // First, try using sessionStore.all if available
+    if (typeof sessionStore.all === 'function') {
+      sessionStore.all(async (err, sessions) => {
+        if (err) {
+          console.log('[AutoStart] Could not retrieve sessions for auto-start:', err.message);
+          // Fall through to file-based enumeration
+          await tryFileBasedAutoStart(contextDir, cloudAuth, linkedinAutomation);
+          return;
+        }
+
+        if (!sessions || Object.keys(sessions).length === 0) {
+          console.log('[AutoStart] No existing sessions found, skipping auto-start');
+          return;
+        }
+
+        // Try to find an authenticated session
+        for (const sessionId in sessions) {
+          const sessionData = sessions[sessionId];
+          if (sessionData && sessionData.tokens && sessionData.tokens.idToken && sessionData.tokens.accessToken) {
+            const success = await tryStartAutomationWithSession(sessionData, cloudAuth, linkedinAutomation);
+            if (success) return; // Successfully started, exit function
+          }
+        }
+
+        console.log('[AutoStart] No valid authenticated session found, skipping auto-start');
+      });
+    } else {
+      // Fall back to file-based enumeration
+      await tryFileBasedAutoStart(contextDir, cloudAuth, linkedinAutomation);
+    }
+  } catch (error) {
+    console.error('[AutoStart] Error during auto-start check:', error.message);
+  }
+}
+
+/**
+ * Try to start automation by reading session files directly from the filesystem
+ */
+async function tryFileBasedAutoStart(contextDir, cloudAuth, linkedinAutomation) {
+  try {
+    // session-file-store may store sessions in a 'sessions' subdirectory or directly in contextDir
+    let sessionsDir = path.join(contextDir, 'sessions');
+    let sessionFiles = [];
+    
+    // First try the sessions subdirectory
+    if (fs.existsSync(sessionsDir)) {
+      sessionFiles = fs.readdirSync(sessionsDir)
+        .filter(file => file.endsWith('.json'))
+        .map(file => path.join(sessionsDir, file));
+    }
+    
+    // If no files found in subdirectory, check the context directory directly
+    if (sessionFiles.length === 0 && fs.existsSync(contextDir)) {
+      const allFiles = fs.readdirSync(contextDir).filter(file => file.endsWith('.json'));
+      // Filter out non-session files (like storage_state files)
+      sessionFiles = allFiles
+        .filter(file => {
+          const filePath = path.join(contextDir, file);
+          try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const data = JSON.parse(content);
+            // Session files have tokens and cookie structure
+            return data.tokens && data.cookie;
+          } catch {
+            return false;
+          }
+        })
+        .map(file => path.join(contextDir, file));
+    }
+    
+    if (sessionFiles.length === 0) {
+      console.log('[AutoStart] No session files found, skipping auto-start');
+      return;
+    }
+
+    console.log(`[AutoStart] Found ${sessionFiles.length} session file(s), checking for authenticated sessions...`);
+
+    // Try each session file
+    for (const sessionPath of sessionFiles) {
+      try {
+        const fileContent = fs.readFileSync(sessionPath, 'utf8');
+        const sessionData = JSON.parse(fileContent);
+
+        if (sessionData && sessionData.tokens && sessionData.tokens.idToken && sessionData.tokens.accessToken) {
+          const success = await tryStartAutomationWithSession(sessionData, cloudAuth, linkedinAutomation);
+          if (success) return; // Successfully started, exit function
+        }
+      } catch (error) {
+        // Skip invalid session files
+        continue;
+      }
+    }
+
+    console.log('[AutoStart] No valid authenticated session found in session files, skipping auto-start');
+  } catch (error) {
+    console.log('[AutoStart] Error reading session files:', error.message);
+    console.log('[AutoStart] Automation will start when clients connect via WebSocket');
+  }
+}
+
+/**
+ * Try to start automation with a session object
+ * @param {object} sessionData - Session data object with tokens and user info
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} linkedinAutomation - LinkedInAutomation instance
+ * @returns {Promise<boolean>} true if automation started successfully
+ */
+export async function tryStartAutomationWithSession(sessionData, cloudAuth, linkedinAutomation) {
+  try {
+    // Check if automation is already running
+    if (linkedinAutomation.isRunning) {
+      console.log('[AutoStart] Automation is already running, skipping auto-start');
+      return false;
+    }
+
+    // Create a session-like object that works with cloudAuth methods
+    const sessionObj = {
+      tokens: sessionData.tokens,
+      user: sessionData.user
+    };
+
+    // Validate and refresh token if needed
+    const tokenCheck = await cloudAuth.ensureValidToken(sessionObj);
+    if (!tokenCheck.valid) {
+      console.log('[AutoStart] Session token invalid, skipping auto-start');
+      return false;
+    }
+
+    // Start automation with the authenticated session (legacy mode)
+    // Note: This uses the single instance for backward compatibility
+    // New implementations should wait for WebSocket connections
+    console.log('[AutoStart] Auto-starting automation with authenticated session (legacy mode)...');
+    linkedinAutomation._currentAccessToken = sessionObj.tokens.idToken;
+    linkedinAutomation._currentRefreshToken = sessionObj.tokens.refreshToken;
+    linkedinAutomation._currentUserEmail = sessionObj.user?.email || 'default_user';
+    await linkedinAutomation.startAutomation(true); // Start in headless mode by default
+    console.log('[AutoStart] ✅ Automation auto-started successfully (legacy mode)');
+    return true;
+  } catch (error) {
+    console.error('[AutoStart] Error during auto-start:', error.message);
+    return false;
+  }
+}

package/helpers/token_sync.js

@@ -0,0 +1,77 @@
+/**
+ * Token Synchronization Helper
+ * 
+ * Handles synchronization of authentication tokens between sessions
+ * and LinkedIn automation processes.
+ */
+
+/**
+ * Sync tokens from session to LinkedInAutomation
+ * Supports both legacy single instance and new multi-process state
+ * 
+ * @param {object} session - Express session object
+ * @param {string|null} socketId - Optional socket ID for process-specific sync
+ * @param {object} appState - AppState instance (optional, for multi-process)
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} linkedinAutomation - Legacy LinkedInAutomation instance (optional)
+ */
+export function syncTokensToAutomation(session, socketId, appState, cloudAuth, linkedinAutomation = null) {
+  if (!session?.tokens || !session?.user) {
+    return;
+  }
+  
+  // If socketId provided, sync to specific process
+  if (socketId && appState) {
+    const process = appState.getProcess(socketId);
+    if (process && process.automation && process.automation.isRunning) {
+      const hadExpiredToken = process.automation._currentAccessToken && 
+                              cloudAuth.isTokenExpired(process.automation._currentAccessToken);
+      
+      process.automation._currentAccessToken = session.tokens.idToken;
+      process.automation._currentRefreshToken = session.tokens.refreshToken;
+      
+      if (hadExpiredToken) {
+        console.log(`[TokenSync] Synced refreshed tokens to process ${socketId} for user:`, session.user.email);
+      }
+    }
+  } else if (linkedinAutomation) {
+    // Legacy: sync to single automation instance
+    if (linkedinAutomation.isRunning && 
+        linkedinAutomation._currentUserEmail === session.user.email) {
+      const hadExpiredToken = linkedinAutomation._currentAccessToken && 
+                              cloudAuth.isTokenExpired(linkedinAutomation._currentAccessToken);
+      
+      linkedinAutomation._currentAccessToken = session.tokens.idToken;
+      linkedinAutomation._currentRefreshToken = session.tokens.refreshToken;
+      
+      if (hadExpiredToken) {
+        console.log('[TokenSync] Synced refreshed tokens to LinkedInAutomation for user:', session.user.email);
+      }
+    }
+  }
+}
+
+/**
+ * Sync tokens to all processes for a specific user
+ * 
+ * @param {object} session - Express session object
+ * @param {string} userEmail - User email address
+ * @param {object} appState - AppState instance
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} linkedinAutomation - Legacy LinkedInAutomation instance (optional)
+ */
+export function syncTokensToAllUserProcesses(session, userEmail, appState, cloudAuth, linkedinAutomation = null) {
+  if (!userEmail || !appState) {
+    return;
+  }
+
+  const userProcesses = appState.getProcessesByUser(userEmail);
+  userProcesses.forEach(process => {
+    syncTokensToAutomation(session, process.socketId, appState, cloudAuth);
+  });
+
+  // Also sync to legacy instance if provided
+  if (linkedinAutomation) {
+    syncTokensToAutomation(session, null, null, cloudAuth, linkedinAutomation);
+  }
+}

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/middleware/auth.js

@@ -0,0 +1,38 @@
+import { syncTokensToAllUserProcesses } from '../helpers/token_sync.js';
+
+/**
+ * Authentication Middleware
+ * 
+ * Handles token validation and refresh for authenticated requests.
+ */
+
+/**
+ * Middleware to automatically refresh tokens if expired
+ * and sync them to all user processes
+ * 
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} appState - AppState instance
+ * @param {object} linkedinAutomation - Legacy LinkedInAutomation instance (optional)
+ * @returns {Function} Express middleware function
+ */
+export function createAutoRefreshTokenMiddleware(cloudAuth, appState, linkedinAutomation = null) {
+  return async (req, res, next) => {
+    if (cloudAuth.isAuthenticated(req.session)) {
+      const tokenWasExpired = req.session.tokens?.idToken && 
+                              cloudAuth.isTokenExpired(req.session.tokens.idToken);
+      
+      const tokenCheck = await cloudAuth.ensureValidToken(req.session);
+      if (!tokenCheck.valid) {
+        console.log('[AuthMiddleware] Token validation failed:', tokenCheck.error);
+        cloudAuth.clearSession(req.session);
+      } else if (tokenWasExpired) {
+        // Tokens were refreshed, sync to all processes for this user
+        const userEmail = req.session.user?.email;
+        if (userEmail) {
+          syncTokensToAllUserProcesses(req.session, userEmail, appState, cloudAuth, linkedinAutomation);
+        }
+      }
+    }
+    next();
+  };
+}

package/package.json

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

package/routes/auth.js

@@ -0,0 +1,110 @@
+import express from 'express';
+import { syncTokensToAllUserProcesses } from '../helpers/token_sync.js';
+import { tryStartAutomationWithSession } from '../helpers/auto_start.js';
+
+/**
+ * Authentication Routes
+ * 
+ * Handles authentication endpoints including login, callback, logout, and token refresh.
+ */
+
+/**
+ * Create authentication routes
+ * 
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {number} port - Server port number
+ * @param {object} appState - AppState instance
+ * @param {object} linkedinAutomation - Legacy LinkedInAutomation instance (optional)
+ * @returns {Router} Express router
+ */
+export function createAuthRoutes(cloudAuth, port, appState, linkedinAutomation = null) {
+  const router = express.Router();
+
+  router.get('/status', (req, res) => {
+    res.json(cloudAuth.getAuthStatus(req.session));
+  });
+
+  router.get('/login', async (req, res) => {
+    const redirectUri = `http://localhost:${port}/auth/callback`;
+    const result = await cloudAuth.getLoginUrl(redirectUri);
+    
+    if (result.success) {
+      console.log('[Auth] Redirecting to login URL:', result.loginUrl);
+      res.redirect(result.loginUrl);
+    } else {
+      console.error('[Auth] Failed to get login URL:', result.error);
+      res.redirect('/?error=' + encodeURIComponent('Failed to get login URL: ' + result.error));
+    }
+  });
+
+  router.get('/callback', async (req, res) => {
+    const { code } = req.query;
+    const redirectUri = `http://localhost:${port}/auth/callback`;
+    
+    if (!code) {
+      console.error('[Auth] No authorization code received');
+      return res.redirect('/?error=no_code');
+    }
+    
+    const result = await cloudAuth.exchangeCodeForTokens(code, redirectUri);
+    
+    if (result.success) {
+      cloudAuth.storeTokensInSession(req.session, result.tokens, result.user);
+      
+      // Auto-start automation after successful authentication
+      if (linkedinAutomation) {
+        const sessionData = {
+          tokens: result.tokens,
+          user: result.user
+        };
+        // Start automation asynchronously (don't block the redirect)
+        tryStartAutomationWithSession(sessionData, cloudAuth, linkedinAutomation).catch(err => {
+          console.error('[Auth] Auto-start automation failed after login:', err.message);
+        });
+      }
+      
+      res.redirect('/dashboard?login=success');
+    } else {
+      console.error('[Auth] Token exchange failed:', result.error);
+      res.redirect('/login?error=' + encodeURIComponent(result.error));
+    }
+  });
+
+  router.post('/refresh', async (req, res) => {
+    if (!req.session.tokens?.refreshToken) {
+      return res.status(401).json({ error: 'No refresh token available' });
+    }
+    
+    const result = await cloudAuth.refreshTokens(req.session.tokens.refreshToken);
+    
+    if (result.success) {
+      cloudAuth.storeTokensInSession(req.session, result.tokens, result.user);
+      console.log('[Auth] Token refreshed successfully');
+      
+      // Sync tokens to all processes for this user
+      const userEmail = req.session.user?.email;
+      if (userEmail) {
+        syncTokensToAllUserProcesses(req.session, userEmail, appState, cloudAuth, linkedinAutomation);
+      }
+      
+      res.json({ success: true });
+    } else {
+      console.error('[Auth] Token refresh failed:', result.error);
+      res.status(401).json({ error: result.error });
+    }
+  });
+
+  router.post('/logout', (req, res) => {
+    cloudAuth.clearSession(req.session);
+    req.session.destroy((err) => {
+      if (err) {
+        console.error('[Auth] Error during logout:', err);
+        return res.status(500).json({ error: 'Logout failed' });
+      }
+      console.log('[Auth] User logged out');
+      res.json({ success: true });
+    });
+  });
+
+  return router;
+}

package/routes/automation.js

@@ -0,0 +1,199 @@
+import express from 'express';
+
+/**
+ * Automation Routes
+ * 
+ * Handles automation control endpoints including start, stop, status, and settings.
+ */
+
+/**
+ * Create automation routes
+ * 
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} appState - AppState instance
+ * @param {object} linkedinAutomation - Legacy LinkedInAutomation instance
+ * @param {Server} io - Socket.IO server instance
+ * @returns {Router} Express router
+ */
+export function createAutomationRoutes(cloudAuth, appState, linkedinAutomation, io) {
+  const router = express.Router();
+
+  router.post('/start', async (req, res) => {
+    if (!cloudAuth.isAuthenticated(req.session)) {
+      return res.status(401).json({ error: 'Authentication required' });
+    }
+
+    try {
+      const { headless = false, socketId = null } = req.body;
+      
+      // If socketId provided, use process-specific automation
+      // Otherwise, use legacy single instance (for backward compatibility)
+      let automation;
+      let processSocketId = socketId;
+      
+      if (socketId) {
+        let process = appState.getProcess(socketId);
+        if (!process) {
+          // Create process if it doesn't exist
+          process = appState.createProcess(socketId, req.session, io);
+        }
+        automation = process.automation;
+        processSocketId = socketId;
+      } else {
+        // Legacy: use single automation instance
+        automation = linkedinAutomation;
+        console.warn('[Automation] Starting automation without socketId - using legacy single instance');
+      }
+      
+      automation._currentAccessToken = req.session.tokens.idToken;
+      automation._currentRefreshToken = req.session.tokens.refreshToken;
+      automation._currentUserEmail = req.session.user.email;
+      
+      await automation.startAutomation(headless);
+      
+      // Update process status
+      if (processSocketId) {
+        appState.updateProcessStatus(processSocketId, {
+          phase: automation.currentPhase || 'running',
+          isRunning: automation.isRunning,
+          startedAt: new Date().toISOString()
+        });
+      }
+      
+      res.json({ 
+        success: true, 
+        message: 'Automation started',
+        socketId: processSocketId,
+        processId: processSocketId
+      });
+    } catch (error) {
+      console.error('[Automation] Failed to start automation:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  router.post('/stop', async (req, res) => {
+    try {
+      const { socketId = null } = req.body;
+      
+      // If socketId provided, stop specific process
+      // Otherwise, stop legacy single instance
+      let automation;
+      
+      if (socketId) {
+        const process = appState.getProcess(socketId);
+        if (!process) {
+          return res.status(404).json({ error: 'Process not found' });
+        }
+        automation = process.automation;
+        
+        await automation.stopAutomation();
+        
+        // Update process status
+        appState.updateProcessStatus(socketId, {
+          phase: 'idle',
+          isRunning: false
+        });
+      } else {
+        // Legacy: stop single automation instance
+        automation = linkedinAutomation;
+        await automation.stopAutomation();
+      }
+      
+      res.json({ success: true, message: 'Automation stopped' });
+    } catch (error) {
+      console.error('[Automation] Failed to stop automation:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  router.get('/status', (req, res) => {
+    const { socketId = null } = req.query;
+    
+    // If socketId provided, get status for specific process
+    // Otherwise, return legacy single instance status + global summary
+    if (socketId) {
+      const process = appState.getProcess(socketId);
+      if (!process) {
+        return res.status(404).json({ error: 'Process not found' });
+      }
+      
+      const status = process.automation.getStatus();
+      res.json({
+        ...status,
+        socketId: process.socketId,
+        userId: process.session.userId,
+        metadata: process.metadata
+      });
+    } else {
+      // Legacy: return single instance status + global state summary
+      const legacyStatus = linkedinAutomation.getStatus();
+      res.json({
+        ...legacyStatus,
+        globalState: appState.getSummary(),
+        stats: appState.getStats()
+      });
+    }
+  });
+
+  router.post('/settings', async (req, res) => {
+    if (!cloudAuth.isAuthenticated(req.session)) {
+      return res.status(401).json({ error: 'Authentication required' });
+    }
+
+    try {
+      const { keepBrowser, socketId = null } = req.body;
+      
+      if (typeof keepBrowser !== 'boolean') {
+        return res.status(400).json({ error: 'keepBrowser must be a boolean' });
+      }
+
+      // If socketId provided, update specific process
+      // Otherwise, update legacy single instance
+      let automation;
+      
+      if (socketId) {
+        const process = appState.getProcess(socketId);
+        if (!process) {
+          return res.status(404).json({ error: 'Process not found' });
+        }
+        automation = process.automation;
+      } else {
+        // Legacy: update single automation instance
+        automation = linkedinAutomation;
+      }
+
+      await automation.updateBrowserVisibility(keepBrowser);
+      res.json({ success: true, message: 'Browser visibility setting updated' });
+    } catch (error) {
+      console.error('[Automation] Failed to update browser settings:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+}
+
+/**
+ * Create state routes
+ * 
+ * @param {object} cloudAuth - CloudAuth instance
+ * @param {object} appState - AppState instance
+ * @returns {Router} Express router
+ */
+export function createStateRoutes(cloudAuth, appState) {
+  const router = express.Router();
+
+  router.get('/', (req, res) => {
+    if (!cloudAuth.isAuthenticated(req.session)) {
+      return res.status(401).json({ error: 'Authentication required' });
+    }
+    
+    res.json({
+      summary: appState.getSummary(),
+      stats: appState.getStats()
+    });
+  });
+
+  return router;
+}

package/server.js

@@ -7,39 +7,55 @@ import { fileURLToPath } from 'url';
 import dotenv from 'dotenv';
 import { createServer } from 'http';
 import { Server } from 'socket.io';
-import { execSync } from 'child_process';
+
 import { CloudAuth } from './cloud_auth.js';
 import { LinkedInAutomation } from './linkedin_automation.js';
 import { getContextDirectory } from './tools/context_paths.js';
+import { AppState } from './state/app_state.js';
+import { createAutoRefreshTokenMiddleware } from './middleware/auth.js';
+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();
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const FileStoreSession = FileStore(session);
-
+// Initialize Express app and HTTP server
 const app = express();
 const server = createServer(app);
 const io = new Server(server);
 const PORT = process.env.PORT || 323;
+
+// Initialize core services
 const cloudAuth = new CloudAuth();
-const linkedinAutomation = new LinkedInAutomation(io);
-const contextDir = getContextDirectory();
+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;
 };
 
+// Initialize session store
+const FileStoreSession = FileStore(session);
+const contextDir = getContextDirectory();
+const sessionStore = new FileStoreSession({
+  path: contextDir,
+  ttl: 30 * 24 * 60 * 60,
+  retries: 0
+});
+
+// Configure Express middleware
 app.use(express.json());
 app.use(express.static(path.join(__dirname, 'public')));
 
 app.use(session({
-  store: new FileStoreSession({
-    path: contextDir,
-    ttl: 30 * 24 * 60 * 60,
-    retries: 0
-  }),
+  store: sessionStore,
   secret: cloudAuth.sessionSecret,
   resave: false,
   saveUninitialized: false,
@@ -50,169 +66,52 @@ app.use(session({
   }
 }));
 
-const autoRefreshTokenMiddleware = async (req, res, next) => {
-  if (cloudAuth.isAuthenticated(req.session)) {
-    const tokenCheck = await cloudAuth.ensureValidToken(req.session);
-    if (!tokenCheck.valid) {
-      console.log('[Server] Token validation failed:', tokenCheck.error);
-      cloudAuth.clearSession(req.session);
-    }
-  }
-  next();
-};
-
-app.use(autoRefreshTokenMiddleware);
+// Apply authentication middleware
+app.use(createAutoRefreshTokenMiddleware(cloudAuth, appState, linkedinAutomation));
 
+// Basic routes
 app.get('/', (req, res) => {
-    if (cloudAuth.isAuthenticated(req.session)) {
-        res.sendFile(path.join(__dirname, 'public', 'dashboard.html'));
-    } else {
-        res.sendFile(path.join(__dirname, 'public', 'login.html'));
-    }
-});
-
-app.get('/login', (req, res) => {
-    res.sendFile(path.join(__dirname, 'public', 'login.html'));
-});
-
-app.get('/dashboard', (req, res) => {
-    if (cloudAuth.isAuthenticated(req.session)) {
-        res.sendFile(path.join(__dirname, 'public', 'dashboard.html'));
-    } else {
-        res.redirect('/login');
-    }
-});
-
-app.get('/auth/status', (req, res) => {
-  res.json(cloudAuth.getAuthStatus(req.session));
-});
-
-app.get('/auth/login', async (req, res) => {
-  const redirectUri = `http://localhost:${PORT}/auth/callback`;
-  const result = await cloudAuth.getLoginUrl(redirectUri);
-  
-  if (result.success) {
-    console.log('[Server] Redirecting to login URL:', result.loginUrl);
-    res.redirect(result.loginUrl);
+  if (cloudAuth.isAuthenticated(req.session)) {
+    res.sendFile(path.join(__dirname, 'public', 'dashboard.html'));
   } else {
-    console.error('[Server] Failed to get login URL:', result.error);
-    res.redirect('/?error=' + encodeURIComponent('Failed to get login URL: ' + result.error));
+    res.sendFile(path.join(__dirname, 'public', 'login.html'));
   }
 });
 
-app.get('/auth/callback', async (req, res) => {
-  const { code } = req.query;
-  const redirectUri = `http://localhost:${PORT}/auth/callback`;
-  
-  if (!code) {
-    console.error('[Server] No authorization code received');
-    return res.redirect('/?error=no_code');
-  }
-  
-  const result = await cloudAuth.exchangeCodeForTokens(code, redirectUri);
-  
-  if (result.success) {
-    cloudAuth.storeTokensInSession(req.session, result.tokens, result.user);
-    res.redirect('/dashboard?login=success');
-  } else {
-    console.error('[Server] Token exchange failed:', result.error);
-    res.redirect('/login?error=' + encodeURIComponent(result.error));
-  }
+app.get('/login', (req, res) => {
+  res.sendFile(path.join(__dirname, 'public', 'login.html'));
 });
 
-app.post('/auth/refresh', async (req, res) => {
-  if (!req.session.tokens?.refreshToken) {
-    return res.status(401).json({ error: 'No refresh token available' });
-  }
-  
-  const result = await cloudAuth.refreshTokens(req.session.tokens.refreshToken);
-  
-  if (result.success) {
-    cloudAuth.storeTokensInSession(req.session, result.tokens, result.user);
-    console.log('[Server] Token refreshed successfully');
-    res.json({ success: true });
+app.get('/dashboard', (req, res) => {
+  if (cloudAuth.isAuthenticated(req.session)) {
+    res.sendFile(path.join(__dirname, 'public', 'dashboard.html'));
   } else {
-    console.error('[Server] Token refresh failed:', result.error);
-    res.status(401).json({ error: result.error });
-  }
-});
-
-app.post('/api/automation/start', async (req, res) => {
-  if (!cloudAuth.isAuthenticated(req.session)) {
-    return res.status(401).json({ error: 'Authentication required' });
-  }
-
-  try {
-    const { headless = false } = req.body;
-    linkedinAutomation._currentAccessToken = req.session.tokens.idToken;
-    linkedinAutomation._currentRefreshToken = req.session.tokens.refreshToken;
-    linkedinAutomation._currentUserEmail = req.session.user.email;
-    await linkedinAutomation.startAutomation(headless);
-    res.json({ success: true, message: 'Automation started' });
-  } catch (error) {
-    console.error('[Server] Failed to start automation:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
-
-app.post('/api/automation/stop', async (req, res) => {
-  try {
-    await linkedinAutomation.stopAutomation();
-    res.json({ success: true, message: 'Automation stopped' });
-  } catch (error) {
-    console.error('[Server] Failed to stop automation:', error);
-    res.status(500).json({ error: error.message });
+    res.redirect('/login');
   }
 });
 
-app.get('/api/automation/status', (req, res) => {
-  res.json(linkedinAutomation.getStatus());
-});
-
-app.post('/api/automation/settings', async (req, res) => {
-  if (!cloudAuth.isAuthenticated(req.session)) {
-    return res.status(401).json({ error: 'Authentication required' });
-  }
-
-  try {
-    const { keepBrowser } = req.body;
-    
-    if (typeof keepBrowser !== 'boolean') {
-      return res.status(400).json({ error: 'keepBrowser must be a boolean' });
-    }
-
-    await linkedinAutomation.updateBrowserVisibility(keepBrowser);
-    res.json({ success: true, message: 'Browser visibility setting updated' });
-  } catch (error) {
-    console.error('[Server] Failed to update browser settings:', error);
-    res.status(500).json({ error: error.message });
-  }
-});
-
-io.on('connection', (socket) => {
-  console.log('[Server] Client connected:', socket.id);
-  
-  socket.on('disconnect', () => {
-    console.log('[Server] Client disconnected:', socket.id);
-  });
-});
+// API routes
+app.use('/auth', createAuthRoutes(cloudAuth, PORT, appState, linkedinAutomation));
+app.use('/api/automation', createAutomationRoutes(cloudAuth, appState, linkedinAutomation, io));
+app.use('/api/state', createStateRoutes(cloudAuth, appState));
 
-app.post('/auth/logout', (req, res) => {
-  cloudAuth.clearSession(req.session);
-  req.session.destroy((err) => {
-    if (err) {
-      console.error('[Server] Error during logout:', err);
-      return res.status(500).json({ error: 'Logout failed' });
-    }
-    console.log('[Server] User logged out');
-    res.json({ success: true });
-  });
-});
+// Setup WebSocket handlers
+setupSocketHandlers(io, appState);
 
-server.listen(PORT, () => {
+// Start server
+server.listen(PORT, async () => {
   console.log('');
   console.log(` Server running: http://localhost:${PORT}`);
   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);
+  }, 1000);
 });
-

package/socket/handlers.js

@@ -0,0 +1,48 @@
+/**
+ * WebSocket Handlers
+ * 
+ * Handles WebSocket connections and manages process state for each connection.
+ */
+
+/**
+ * Setup WebSocket connection handlers
+ * 
+ * @param {Server} io - Socket.IO server instance
+ * @param {object} appState - AppState instance
+ */
+export function setupSocketHandlers(io, appState) {
+  io.on('connection', (socket) => {
+    console.log('[Socket] Client connected:', socket.id);
+    
+    // Get session from socket handshake (if available)
+    const session = socket.request?.session;
+    
+    // Create process state for this connection
+    const processState = appState.createProcess(socket.id, session || {}, io);
+    
+    // Update metadata with connection info
+    appState.updateProcessMetadata(socket.id, {
+      userAgent: socket.request?.headers['user-agent'] || null,
+      ipAddress: socket.request?.connection?.remoteAddress || null
+    });
+    
+    // Handle session updates
+    socket.on('session_update', (sessionData) => {
+      const process = appState.getProcess(socket.id);
+      if (process) {
+        process.session = {
+          userId: sessionData?.user?.email || null,
+          sessionId: sessionData?.id || null,
+          authenticated: sessionData?.tokens ? true : false
+        };
+      }
+    });
+    
+    socket.on('disconnect', async () => {
+      console.log('[Socket] Client disconnected:', socket.id);
+      
+      // Cleanup process state
+      await appState.removeProcess(socket.id);
+    });
+  });
+}

package/state/app_state.js

@@ -0,0 +1,214 @@
+import { LinkedInAutomation } from '../linkedin_automation.js';
+
+/**
+ * Global Application State Manager
+ * 
+ * Manages state for multiple concurrent LinkedIn automation processes.
+ * Each process is associated with a WebSocket connection (tab) and has its own
+ * LinkedInAutomation instance, user session, and status.
+ * 
+ * Design Principles:
+ * - Single Responsibility: Manages only state tracking
+ * - Encapsulation: Private state with controlled access methods
+ * - Scalability: Supports multiple concurrent processes
+ * - Cleanup: Automatic cleanup on disconnect
+ */
+export class AppState {
+  constructor() {
+    // Private state: Map of socketId -> process state
+    this._processes = new Map();
+    
+    // Statistics
+    this._stats = {
+      totalProcessesCreated: 0,
+      totalProcessesDestroyed: 0,
+      activeProcesses: 0
+    };
+  }
+
+  /**
+   * Create a new automation process for a socket connection
+   * @param {string} socketId - WebSocket connection ID
+   * @param {object} session - Express session object
+   * @param {Server} io - Socket.IO server instance
+   * @returns {object} Process state object
+   */
+  createProcess(socketId, session, io) {
+    if (this._processes.has(socketId)) {
+      console.warn(`[AppState] Process already exists for socket ${socketId}`);
+      return this._processes.get(socketId);
+    }
+
+    const automation = new LinkedInAutomation(io);
+    automation.getAccessToken = function() {
+      return this._currentAccessToken || null;
+    };
+
+    const processState = {
+      socketId,
+      automation,
+      session: {
+        userId: session?.user?.email || null,
+        sessionId: session?.id || null,
+        authenticated: session?.tokens ? true : false
+      },
+      status: {
+        phase: 'idle',
+        isRunning: false,
+        startedAt: null,
+        lastActivityAt: new Date().toISOString()
+      },
+      metadata: {
+        createdAt: new Date().toISOString(),
+        userAgent: null,
+        ipAddress: null
+      }
+    };
+
+    this._processes.set(socketId, processState);
+    this._stats.totalProcessesCreated++;
+    this._stats.activeProcesses = this._processes.size;
+
+    console.log(`[AppState] Created process for socket ${socketId} (total active: ${this._stats.activeProcesses})`);
+    return processState;
+  }
+
+  /**
+   * Get process state by socket ID
+   * @param {string} socketId - WebSocket connection ID
+   * @returns {object|null} Process state or null if not found
+   */
+  getProcess(socketId) {
+    return this._processes.get(socketId) || null;
+  }
+
+  /**
+   * Get all active processes
+   * @returns {Array} Array of process state objects
+   */
+  getAllProcesses() {
+    return Array.from(this._processes.values());
+  }
+
+  /**
+   * Get processes by user email
+   * @param {string} userEmail - User email address
+   * @returns {Array} Array of process state objects for the user
+   */
+  getProcessesByUser(userEmail) {
+    return this.getAllProcesses().filter(
+      process => process.session.userId === userEmail
+    );
+  }
+
+  /**
+   * Update process status
+   * @param {string} socketId - WebSocket connection ID
+   * @param {object} updates - Status updates
+   */
+  updateProcessStatus(socketId, updates) {
+    const process = this._processes.get(socketId);
+    if (!process) {
+      console.warn(`[AppState] Cannot update status - process not found for socket ${socketId}`);
+      return;
+    }
+
+    Object.assign(process.status, updates);
+    process.status.lastActivityAt = new Date().toISOString();
+  }
+
+  /**
+   * Update process metadata
+   * @param {string} socketId - WebSocket connection ID
+   * @param {object} metadata - Metadata updates
+   */
+  updateProcessMetadata(socketId, metadata) {
+    const process = this._processes.get(socketId);
+    if (!process) {
+      console.warn(`[AppState] Cannot update metadata - process not found for socket ${socketId}`);
+      return;
+    }
+
+    Object.assign(process.metadata, metadata);
+  }
+
+  /**
+   * Remove and cleanup a process
+   * @param {string} socketId - WebSocket connection ID
+   * @returns {boolean} True if process was removed, false if not found
+   */
+  async removeProcess(socketId) {
+    const process = this._processes.get(socketId);
+    if (!process) {
+      return false;
+    }
+
+    // Cleanup automation if running
+    if (process.automation && process.automation.isRunning) {
+      try {
+        console.log(`[AppState] Stopping automation for socket ${socketId} before cleanup`);
+        await process.automation.stopAutomation();
+      } catch (error) {
+        console.error(`[AppState] Error stopping automation during cleanup:`, error.message);
+      }
+    }
+
+    this._processes.delete(socketId);
+    this._stats.totalProcessesDestroyed++;
+    this._stats.activeProcesses = this._processes.size;
+
+    console.log(`[AppState] Removed process for socket ${socketId} (total active: ${this._stats.activeProcesses})`);
+    return true;
+  }
+
+  /**
+   * Get application-wide statistics
+   * @returns {object} Statistics object
+   */
+  getStats() {
+    return {
+      ...this._stats,
+      activeProcesses: this._processes.size,
+      processesByUser: this._getProcessesByUserCount()
+    };
+  }
+
+  /**
+   * Get count of processes per user
+   * @private
+   * @returns {object} Map of userEmail -> count
+   */
+  _getProcessesByUserCount() {
+    const counts = {};
+    this._processes.forEach(process => {
+      const userId = process.session.userId || 'anonymous';
+      counts[userId] = (counts[userId] || 0) + 1;
+    });
+    return counts;
+  }
+
+  /**
+   * Get summary of all processes (for debugging/monitoring)
+   * @returns {object} Summary object
+   */
+  getSummary() {
+    const processes = this.getAllProcesses();
+    return {
+      total: processes.length,
+      byStatus: processes.reduce((acc, p) => {
+        const status = p.status.phase || 'unknown';
+        acc[status] = (acc[status] || 0) + 1;
+        return acc;
+      }, {}),
+      byUser: this._getProcessesByUserCount(),
+      processes: processes.map(p => ({
+        socketId: p.socketId,
+        userId: p.session.userId,
+        status: p.status.phase,
+        isRunning: p.status.isRunning,
+        startedAt: p.status.startedAt,
+        createdAt: p.metadata.createdAt
+      }))
+    };
+  }
+}