@ubaidbinwaris/linkedin 1.1.0 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubaidbinwaris/linkedin",
-  "version": "1.1.0",
+  "version": "1.1.3",
   "description": "",
   "main": "index.js",
   "files": [

package/src/auth/checkpoint.js

@@ -28,4 +28,46 @@ async function detectCheckpoint(page) {
   }
 }
 
-module.exports = { detectCheckpoint };
+/**
+ * Handles mobile verification/app approval prompts.
+ * Polls for success (feed navigation) for a set duration.
+ * @param {Page} page
+ * @returns {Promise<boolean>} true if resolved, false if timed out/failed
+ */
+async function handleMobileVerification(page) {
+    try {
+        const isMobileVerif = await page.evaluate(() => {
+            const text = document.body.innerText;
+            // User checks: "Check your LinkedIn app", "Open your LinkedIn app", "Approve the sign-in"
+            return text.includes("Check your LinkedIn app") || 
+                   text.includes("Open your LinkedIn app") ||
+                   text.includes("Tap Yes on the prompt") ||
+                   text.includes("verification request to your device") ||
+                   text.includes("Approve the sign-in");
+        });
+
+        if (!isMobileVerif) return false;
+
+        logger.warn("ACTION REQUIRED: Check your LinkedIn app on your phone! Waiting 2 minutes...");
+        
+        try {
+            // Poll for feed URL for 120 seconds
+            await page.waitForFunction(() => {
+                return window.location.href.includes("/feed") || 
+                       document.querySelector('.global-nav__search');
+            }, { timeout: 120000 });
+
+            logger.info("Mobile verification successful! Resuming...");
+            return true; // Resolved
+        } catch (timeoutErr) {
+            logger.warn("Mobile verification timed out (No approval detected).");
+            return false;
+        }
+
+    } catch (e) {
+         logger.warn(`Mobile verification check failed: ${e.message}`);
+         return false;
+    }
+}
+
+module.exports = { detectCheckpoint, handleMobileVerification };

package/src/login/login.js

@@ -1,13 +1,19 @@
-const { chromium } = require("playwright");
 const logger = require("../utils/logger");
-const { waitForUserResume } = require("../utils/terminal");
-const { loadSession, saveSession } = require("../session/sessionManager");
+const { saveSession, SessionLock } = require("../session/sessionManager");
+const { createBrowser, createContext } = require("../browser/launcher");
+const { detectCheckpoint } = require("../auth/checkpoint");
+const { performCredentialLogin, isLoggedIn } = require("../auth/actions");
+const { randomDelay } = require("../utils/time");
 
 const LINKEDIN_FEED = "https://www.linkedin.com/feed/";
-const LINKEDIN_LOGIN = "https://www.linkedin.com/login";
 
 /**
- * Main authentication entry point
+ * Deterministic Login Flow wrapped in SessionLock
+ * 1. Acquire Lock (queues if busy)
+ * 2. Launch Browser
+ * 3. Load Session -> Check needsValidation
+ * 4. Login/Verify
+ * 5. Save Session (with timestamp)
  */
 async function loginToLinkedIn(options = {}, credentials = null) {
   const email = credentials?.username || process.env.LINKEDIN_EMAIL;
@@ -17,186 +23,110 @@ async function loginToLinkedIn(options = {}, credentials = null) {
     throw new Error("Missing LinkedIn credentials.");
   }
 
-  const browser = await createBrowser(options);
-  const context = await createContext(browser, email);
-  const page = await context.newPage();
-
-  page.setDefaultTimeout(30000);
-
-  try {
-    // Try session-based login
-    await page.goto(LINKEDIN_FEED, { waitUntil: "domcontentloaded" });
-
-    if (await isLoggedIn(page)) {
-      logger.info(`Session valid for ${email}`);
-      return { browser, context, page };
-    }
-
-    logger.info(`Session invalid. Performing credential login for ${email}`);
-    await performCredentialLogin(page, email, password);
-
-    await handleCheckpoint(page, options);
-
-    if (!(await isLoggedIn(page))) {
-      throw new Error("Login failed. Could not verify authenticated state.");
-    }
-
-    await saveSession(context, email);
-    logger.info("Session saved successfully.");
-
-    return { browser, context, page };
-
-  } catch (error) {
-    logger.error(`Login process failed: ${error.message}`);
-    await browser.close();
-    throw error;
-  }
-}
-
-module.exports = loginToLinkedIn;
-
-
-async function createBrowser(options) {
-  return chromium.launch({
-    headless: options.headless ?? false,
-    slowMo: options.slowMo ?? 50,
-    args: ["--no-sandbox", "--disable-setuid-sandbox"],
-  });
-}
-
-async function createContext(browser, email) {
-  const storedContext = await loadSession(browser, email);
-
-  if (storedContext) {
-    logger.info("Loaded stored session.");
-    return storedContext;
-  }
-
-  logger.info("Creating new browser context.");
-  return browser.newContext();
-}
-
-
-async function isLoggedIn(page) {
-  try {
-    await page.waitForSelector(".global-nav__search", { timeout: 10000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-
-async function performCredentialLogin(page, email, password) {
-  await page.goto(LINKEDIN_LOGIN, { waitUntil: "domcontentloaded" });
-
-  await page.fill('input[name="session_key"]', email);
-  await page.fill('input[name="session_password"]', password);
-
-  await Promise.all([
-    page.waitForNavigation({ waitUntil: "domcontentloaded" }),
-    page.click('button[type="submit"]')
-  ]);
-}
-
-
-async function handleCheckpoint(page, options) {
-  // Initial check
-  if (!(await detectCheckpoint(page))) return;
-
-  logger.warn("Checkpoint detected.");
-
-  if (options.headless) {
-    logger.info("Headless mode detected. Attempting auto-resolution...");
-
-    // ---------------------------------------------------------
-    // STRATEGY 1: Click Simple Buttons (Yes, Skip, Continue)
-    // ---------------------------------------------------------
-    try {
-      const clicked = await page.evaluate(() => {
-        const candidates = Array.from(document.querySelectorAll('button, a, [role="button"], input[type="submit"], input[type="button"]'));
-        const targetText = ['Yes', 'Skip', 'Not now', 'Continue', 'Sign in', 'Verify', 'Let’s do it', 'Next'];
-        
-        const btn = candidates.find(b => {
-            const text = (b.innerText || b.value || '').trim();
-            return targetText.some(t => text.includes(t));
-        });
+  // Wrap entire process in lock
+  return SessionLock.withLoginLock(email, async () => {
+      const browser = await createBrowser(options);
+      
+      try {
+        // ----------------------------
+        // STEP 1: Load Session & Context
+        // ----------------------------
+        const context = await createContext(browser, email);
+        const page = await context.newPage();
+        page.setDefaultTimeout(30000); 
+
+        // Check validation cache
+        // needsValidation is attached to context in sectionManager
+        if (context.needsValidation === false) {
+             logger.info(`[${email}] Session validation cached. Skipping feed check.`);
+             await page.goto(LINKEDIN_FEED, { waitUntil: "domcontentloaded" });
+             return { browser, context, page };
+        }
 
-        if (btn) {
-            btn.click();
-            return true;
+        // ----------------------------
+        // STEP 2: Verify Session (if needed)
+        // ----------------------------
+        logger.info(`[${email}] Verifying session...`);
+        await page.goto(LINKEDIN_FEED, { waitUntil: "domcontentloaded" });
+        await randomDelay(1000, 2000);
+
+        if (await isLoggedIn(page)) {
+          logger.info(`[${email}] Session valid ✅`);
+          // Update validation timestamp
+          await saveSession(context, email, true);
+          return { browser, context, page };
         }
-        return false;
-      });
 
-      if (clicked) {
-        logger.info("Clicked a resolution button. Waiting for navigation...");
-        await page.waitForTimeout(3000);
+        logger.info(`[${email}] Session invalid. Attempting credential login...`);
         
-        // Check if resolved
-        if (!(await detectCheckpoint(page))) {
-             logger.info("Checkpoint resolved via button click!");
-             return;
+        // ----------------------------
+        // STEP 3: Credential Login
+        // ----------------------------
+        await performCredentialLogin(page, email, password);
+
+        // ----------------------------
+        // STEP 4: Verify & Fail Fast
+        // ----------------------------
+        if (await detectCheckpoint(page)) {
+           // Attempt to handle mobile verification (2 min wait)
+           // If it returns true, it means we are now on the feed (resolved)
+           if (await handleMobileVerification(page)) {
+               // success, assume logged in
+           } else {
+               // Failed mobile verification. 
+               // User Request: "otherwise after some delay using browser opens the browser and fill the form"
+               
+               if (options.headless) {
+                   logger.info("[Fallback] Mobile verification failed. Switching to VISIBLE browser for manual intervention...");
+                   await browser.close();
+
+                   // RE-LAUNCH in Visible Mode
+                   const visibleBrowser = await createBrowser({ ...options, headless: false });
+                   const visibleContext = await createContext(visibleBrowser, email);
+                   const visiblePage = await visibleContext.newPage();
+                   visiblePage.setDefaultTimeout(60000); // More time for manual interaction
+
+                   try {
+                       logger.info("[Fallback] Filling credentials in visible browser...");
+                       await performCredentialLogin(visiblePage, email, password);
+                       
+                       // Now wait for success (Feed)
+                       logger.info("[Fallback] Waiting for user to complete login manually...");
+                       await visiblePage.waitForSelector(".global-nav__search", { timeout: 120000 });
+                       
+                       if (await isLoggedIn(visiblePage)) {
+                            logger.info(`[${email}] Manual Fallback Successful ✅`);
+                            await saveSession(visibleContext, email, true);
+                            return { browser: visibleBrowser, context: visibleContext, page: visiblePage };
+                       }
+                   } catch (fallbackErr) {
+                       logger.error(`[Fallback] Manual intervention failed or timed out: ${fallbackErr.message}`);
+                       await visibleBrowser.close();
+                       throw new Error("CHECKPOINT_DETECTED_M"); // M for manual failed
+                   }
+               }
+
+               const screenshotPath = `checkpoint_${email}_${Date.now()}.png`;
+               await page.screenshot({ path: screenshotPath });
+               logger.warn(`[${email}] Checkpoint detected! Screenshot saved: ${screenshotPath}`);
+               throw new Error("CHECKPOINT_DETECTED");
+           }
         }
-      }
-    } catch (e) {
-      logger.warn(`Auto-resolve button click failed: ${e.message}`);
-    }
-
-    // ---------------------------------------------------------
-    // STRATEGY 2: Mobile App Verification (Wait & Poll)
-    // ---------------------------------------------------------
-    try {
-        const isMobileVerif = await page.evaluate(() => {
-            const text = document.body.innerText;
-            return text.includes("Open your LinkedIn app") || 
-                   text.includes("Tap Yes on the prompt") ||
-                   text.includes("verification request to your device");
-        });
 
-        if (isMobileVerif) {
-            logger.info("Mobile verification detected. Waiting 2 minutes for manual approval on device...");
-            
-            try {
-                // Poll for feed URL for 120 seconds
-                // We use a loop or waitForFunction
-                await page.waitForFunction(() => {
-                    return window.location.href.includes("/feed") || 
-                           document.querySelector('.global-nav__search');
-                }, { timeout: 120000 });
-
-                logger.info("Mobile verification successful! Resuming...");
-                return;
-            } catch (timeoutErr) {
-                logger.warn("Mobile verification timed out.");
-            }
+        if (await isLoggedIn(page)) {
+           logger.info(`[${email}] Login successful ✅`);
+           await saveSession(context, email, true); // Save with validation = true
+           return { browser, context, page };
+        } else {
+           throw new Error("LOGIN_FAILED: Could not verify session after login attempt.");
         }
-    } catch (e) {
-         logger.warn(`Mobile verification check failed: ${e.message}`);
-    }
-
-    // Re-check after attempts
-    if (await detectCheckpoint(page)) {
-        throw new Error("Checkpoint detected in headless mode and auto-resolution failed.");
-    }
-
-  } else {
-    // Visible mode
-    logger.warn("Verification required. Please complete manually.");
-    await waitForUserResume(
-      "Complete verification in browser, then press ENTER..."
-    );
-  }
-}
-
-async function detectCheckpoint(page) {
-  const url = page.url().toLowerCase();
 
-  return (
-    url.includes("checkpoint") ||
-    url.includes("challenge") ||
-    url.includes("verification") ||
-    url.includes("consumer-login/error")
-  );
+      } catch (error) {
+        logger.error(`[${email}] Login process failed: ${error.message}`);
+        await browser.close();
+        throw error;
+      }
+  });
 }
 
+module.exports = loginToLinkedIn;