coffeeinabit 0.0.35 → 0.0.46

package/Makefile

@@ -1,3 +1,12 @@
-patch-and-publish:
-	npm version patch
-	npm publish
+patch-and-publish:
+	@echo "Checking npm authentication..."
+	@npm whoami || (echo "Error: Not logged in to npm. Run 'npm login' first." && exit 1)
+	@echo "Authenticated as: $$(npm whoami)"
+	@echo "Verifying npm token in ~/.npmrc..."
+	@grep -q "//registry.npmjs.org/:_authToken=" ~/.npmrc || (echo "Error: No npm token found in ~/.npmrc" && exit 1)
+	@echo "Token found. Publishing..."
+	npm version patch
+	npm publish --access public || (echo "" && echo "❌ Publish failed! If you see a 2FA error:" && echo "   1. Go to: https://www.npmjs.com/settings/kate_yan/tokens" && echo "   2. Create a 'Granular Access Token'" && echo "   3. Enable 'Bypass 2FA' permission" && echo "   4. Update ~/.npmrc with: //registry.npmjs.org/:_authToken=YOUR_NEW_TOKEN" && exit 1)
+
+stop:
+	pm2 stop "npx coffeeinabit" && pm2 delete "npx coffeeinabit" && pkill -9 -f "npm exec coffeeinabit"; pkill -9 -f "npx.*coffeeinabit"; pkill -9 -f "node.*coffeeinabit"

package/cloud_auth.js

@@ -1,170 +1,170 @@
-import axios from 'axios';
-
-export class CloudAuth {
-  constructor() {
-    this.sessionSecret = process.env.SESSION_SECRET || 'coffeeinabit-secret-key-change-in-production';
-  }
-
-  async getLoginUrl(redirectUri) {
-    try {
-      const params = new URLSearchParams({
-        client_id: '4rhqg2pjfhjkq42mr7iilpnmsu',
-        response_type: 'code',
-        redirect_uri: redirectUri,
-        scope: 'openid email profile'
-      });
-      
-      const loginUrl = `https://coffeeinabit.auth.us-east-1.amazoncognito.com/login?${params.toString()}`;
-      
-      return {
-        success: true,
-        loginUrl: loginUrl
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  async exchangeCodeForTokens(code, redirectUri) {
-    try {
-      console.log('[CloudAuth] Received authorization code:', code.substring(0, 10) + '...');
-      console.log('[CloudAuth] Using redirect_uri:', redirectUri);
-      
-      const response = await axios.get(`https://api.coffeeinabit.com/auth/token?code=${encodeURIComponent(code)}&redirect_url=${encodeURIComponent(redirectUri)}`);
-      
-      if (response.data.error) {
-        throw new Error(response.data.error);
-      }
-      
-      const { id_token, access_token, refresh_token } = response.data;
-      
-      return {
-        success: true,
-        tokens: {
-          idToken: id_token,
-          accessToken: access_token,
-          refreshToken: refresh_token
-        },
-        user: this.extractUserFromToken(id_token)
-      };
-    } catch (error) {
-      console.error('[CloudAuth] Token exchange failed:', error.response?.status, error.response?.data);
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  async refreshTokens(refreshToken) {
-    try {
-      const response = await axios.get(
-        `https://api.coffeeinabit.com/auth/refresh?refresh_token=${encodeURIComponent(refreshToken)}`
-      );
-      
-      if (response.data.error) {
-        throw new Error(response.data.error);
-      }
-      
-      return {
-        success: true,
-        tokens: {
-          idToken: response.data.id_token,
-          accessToken: response.data.access_token,
-          refreshToken: response.data.refresh_token || refreshToken
-        },
-        user: this.extractUserFromToken(response.data.id_token)
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  extractUserFromToken(idToken) {
-    if (!idToken) return null;
-    
-    try {
-      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
-      return {
-        email: payload.email || payload['cognito:username'],
-        userId: payload.sub
-      };
-    } catch (error) {
-      console.error('[CloudAuth] Error extracting user from token:', error.message);
-      return null;
-    }
-  }
-
-  isTokenExpired(token) {
-    if (!token) return true;
-    
-    try {
-      const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
-      if (!payload || !payload.exp) return true;
-      
-      const bufferTime = 5 * 60;
-      return payload.exp < (Date.now() / 1000) + bufferTime;
-    } catch (error) {
-      console.error('[CloudAuth] Error checking token expiration:', error.message);
-      return true;
-    }
-  }
-
-  async ensureValidToken(session) {
-    if (!session.tokens?.idToken) {
-      return { valid: false, error: 'No token available' };
-    }
-
-    if (this.isTokenExpired(session.tokens.idToken)) {
-      console.log('[CloudAuth] Token expired or expiring soon, attempting refresh...');
-      
-      if (!session.tokens.refreshToken) {
-        return { valid: false, error: 'No refresh token available' };
-      }
-
-      const result = await this.refreshTokens(session.tokens.refreshToken);
-      
-      if (result.success) {
-        this.storeTokensInSession(session, result.tokens, result.user);
-        return { valid: true };
-      } else {
-        return { valid: false, error: result.error };
-      }
-    }
-
-    return { valid: true };
-  }
-
-  storeTokensInSession(session, tokens, user) {
-    session.tokens = tokens;
-    session.user = user;
-    console.log('[CloudAuth] Tokens stored in session for user:', user?.email);
-  }
-
-  clearSession(session) {
-    session.tokens = null;
-    session.user = null;
-    console.log('[CloudAuth] Session cleared');
-  }
-
-  isAuthenticated(session) {
-    return !!(session.tokens && session.tokens.idToken && session.tokens.accessToken);
-  }
-
-  getAuthStatus(session) {
-    if (this.isAuthenticated(session)) {
-      return {
-        authenticated: true,
-        user: session.user || null
-      };
-    } else {
-      return { authenticated: false };
-    }
-  }
-}
+import axios from 'axios';
+
+export class CloudAuth {
+  constructor() {
+    this.sessionSecret = process.env.SESSION_SECRET || 'coffeeinabit-secret-key-change-in-production';
+  }
+
+  async getLoginUrl(redirectUri) {
+    try {
+      const params = new URLSearchParams({
+        client_id: '4rhqg2pjfhjkq42mr7iilpnmsu',
+        response_type: 'code',
+        redirect_uri: redirectUri,
+        scope: 'openid email profile'
+      });
+      
+      const loginUrl = `https://coffeeinabit.auth.us-east-1.amazoncognito.com/login?${params.toString()}`;
+      
+      return {
+        success: true,
+        loginUrl: loginUrl
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async exchangeCodeForTokens(code, redirectUri) {
+    try {
+      console.log('[CloudAuth] Received authorization code:', code.substring(0, 10) + '...');
+      console.log('[CloudAuth] Using redirect_uri:', redirectUri);
+      
+      const response = await axios.get(`https://api.coffeeinabit.com/auth/token?code=${encodeURIComponent(code)}&redirect_url=${encodeURIComponent(redirectUri)}`);
+      
+      if (response.data.error) {
+        throw new Error(response.data.error);
+      }
+      
+      const { id_token, access_token, refresh_token } = response.data;
+      
+      return {
+        success: true,
+        tokens: {
+          idToken: id_token,
+          accessToken: access_token,
+          refreshToken: refresh_token
+        },
+        user: this.extractUserFromToken(id_token)
+      };
+    } catch (error) {
+      console.error('[CloudAuth] Token exchange failed:', error.response?.status, error.response?.data);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async refreshTokens(refreshToken) {
+    try {
+      const response = await axios.get(
+        `https://api.coffeeinabit.com/auth/refresh?refresh_token=${encodeURIComponent(refreshToken)}`
+      );
+      
+      if (response.data.error) {
+        throw new Error(response.data.error);
+      }
+      
+      return {
+        success: true,
+        tokens: {
+          idToken: response.data.id_token,
+          accessToken: response.data.access_token,
+          refreshToken: response.data.refresh_token || refreshToken
+        },
+        user: this.extractUserFromToken(response.data.id_token)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  extractUserFromToken(idToken) {
+    if (!idToken) return null;
+    
+    try {
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      return {
+        email: payload.email || payload['cognito:username'],
+        userId: payload.sub
+      };
+    } catch (error) {
+      console.error('[CloudAuth] Error extracting user from token:', error.message);
+      return null;
+    }
+  }
+
+  isTokenExpired(token) {
+    if (!token) return true;
+    
+    try {
+      const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+      if (!payload || !payload.exp) return true;
+      
+      const bufferTime = 5 * 60;
+      return payload.exp < (Date.now() / 1000) + bufferTime;
+    } catch (error) {
+      console.error('[CloudAuth] Error checking token expiration:', error.message);
+      return true;
+    }
+  }
+
+  async ensureValidToken(session) {
+    if (!session.tokens?.idToken) {
+      return { valid: false, error: 'No token available' };
+    }
+
+    if (this.isTokenExpired(session.tokens.idToken)) {
+      console.log('[CloudAuth] Token expired or expiring soon, attempting refresh...');
+      
+      if (!session.tokens.refreshToken) {
+        return { valid: false, error: 'No refresh token available' };
+      }
+
+      const result = await this.refreshTokens(session.tokens.refreshToken);
+      
+      if (result.success) {
+        this.storeTokensInSession(session, result.tokens, result.user);
+        return { valid: true };
+      } else {
+        return { valid: false, error: result.error };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  storeTokensInSession(session, tokens, user) {
+    session.tokens = tokens;
+    session.user = user;
+    console.log('[CloudAuth] Tokens stored in session for user:', user?.email);
+  }
+
+  clearSession(session) {
+    session.tokens = null;
+    session.user = null;
+    console.log('[CloudAuth] Session cleared');
+  }
+
+  isAuthenticated(session) {
+    return !!(session.tokens && session.tokens.idToken && session.tokens.accessToken);
+  }
+
+  getAuthStatus(session) {
+    if (this.isAuthenticated(session)) {
+      return {
+        authenticated: true,
+        user: session.user || null
+      };
+    } else {
+      return { authenticated: false };
+    }
+  }
+}

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);
+  }
+}