coffeeinabit 0.0.47 → 0.0.49

package/tools/get_daily_linkedin_connections.js

@@ -1,12 +1,32 @@
 import { safeGoto } from './navigation.js';
 
+const CONNECTIONS_URL = 'https://www.linkedin.com/mynetwork/invite-connect/connections/';
+const MAX_SCROLL_PAGES = 50;
+const MAX_NO_SCROLL_ATTEMPTS = 2;
+const SCROLL_AMOUNT = 2000;
+const SCROLL_WAIT_TIME = 3000;
+const RETRY_WAIT_TIME = 5000;
+
 export async function executeGetDailyLinkedInConnections(page, action) {
-  const lastCheckTimestamp = action.parameters?.last_check_timestamp
+  const lastCheckTimestamp = extractLastCheckTimestamp(action);
+  const now = Date.now();
+  
+  await navigateToConnectionsPage(page);
+  const totalConnections = await extractTotalConnections(page);
+  const allConnections = await collectAllConnections(page, lastCheckTimestamp);
+  const newConnections = filterNewConnections(allConnections, lastCheckTimestamp);
+  
+  return createResult(totalConnections, newConnections, lastCheckTimestamp, now);
+}
+
+function extractLastCheckTimestamp(action) {
+  return action.parameters?.last_check_timestamp
     ? parseInt(action.parameters.last_check_timestamp, 10)
     : null;
-  
-  const url = 'https://www.linkedin.com/mynetwork/invite-connect/connections/';
-  await safeGoto(page, url, {
+}
+
+async function navigateToConnectionsPage(page) {
+  await safeGoto(page, CONNECTIONS_URL, {
     waitUntil: 'domcontentloaded',
     timeout: 60000
   });
@@ -16,101 +36,142 @@ export async function executeGetDailyLinkedInConnections(page, action) {
   });
   
   await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+}
+
+async function collectAllConnections(page, lastCheckTimestamp) {
+  const allConnectionsMap = new Map();
+  const scrollState = {
+    scrollPageCount: 0,
+    noScrollAttempts: 0,
+    shouldStop: false
+  };
   
-  const totalConnections = await extractTotalConnections(page);
-  
-  const now = Date.now();
-  let allConnectionsMap = new Map();
-  let shouldStopScrolling = false;
-  let noScrollAttempts = 0;
-  const maxNoScrollAttempts = 2;
-  
-  while (!shouldStopScrolling) {
-    const currentConnections = await extractCurrentConnections(page);
+  while (!scrollState.shouldStop) {
+    scrollState.scrollPageCount++;
     
-    currentConnections.forEach(conn => {
-      allConnectionsMap.set(conn.username, conn);
-    });
+    if (scrollState.scrollPageCount > MAX_SCROLL_PAGES) {
+      console.log(`[get_daily_linkedin_connections] Reached max scroll pages limit (${MAX_SCROLL_PAGES}), stopping`);
+      scrollState.shouldStop = true;
+      break;
+    }
+    
+    console.log(`[get_daily_linkedin_connections] Scroll page ${scrollState.scrollPageCount}/${MAX_SCROLL_PAGES}`);
+    
+    const currentConnections = await extractCurrentConnections(page);
+    addConnectionsToMap(allConnectionsMap, currentConnections);
     
     console.log(`[get_daily_linkedin_connections] Current page connections: ${currentConnections.length}, Total unique: ${allConnectionsMap.size}`);
     
-    if (lastCheckTimestamp && currentConnections.length > 0) {
-      const oldestConnection = currentConnections.reduce((oldest, current) => {
-        if (!oldest.connectionTimestamp) return current;
-        if (!current.connectionTimestamp) return oldest;
-        return current.connectionTimestamp < oldest.connectionTimestamp ? current : oldest;
-      });
-      
-      if (oldestConnection.connectionTimestamp && oldestConnection.connectionTimestamp < lastCheckTimestamp) {
-        console.log('[get_daily_linkedin_connections] Reached connections older than last check, stopping');
-        shouldStopScrolling = true;
-        break;
-      }
+    if (shouldStopDueToOldConnections(currentConnections, lastCheckTimestamp)) {
+      console.log('[get_daily_linkedin_connections] Reached connections older than last check, stopping');
+      scrollState.shouldStop = true;
+      break;
     }
     
-    const scrollInfoBefore = await getScrollInfo(page);
+    const scrollProgress = await performScrollIteration(page);
+    await updateScrollState(scrollState, scrollProgress);
+  }
+  
+  return Array.from(allConnectionsMap.values());
+}
+
+function addConnectionsToMap(connectionsMap, connections) {
+  connections.forEach(conn => {
+    connectionsMap.set(conn.username, conn);
+  });
+}
+
+function shouldStopDueToOldConnections(currentConnections, lastCheckTimestamp) {
+  if (!lastCheckTimestamp || currentConnections.length === 0) {
+    return false;
+  }
+  
+  const oldestConnection = currentConnections.reduce((oldest, current) => {
+    if (!oldest.connectionTimestamp) return current;
+    if (!current.connectionTimestamp) return oldest;
+    return current.connectionTimestamp < oldest.connectionTimestamp ? current : oldest;
+  });
+  
+  return oldestConnection.connectionTimestamp && 
+         oldestConnection.connectionTimestamp < lastCheckTimestamp;
+}
+
+async function performScrollIteration(page) {
+  const scrollInfoBefore = await getScrollInfo(page);
+  console.log(`[get_daily_linkedin_connections] Before scroll - Top: ${scrollInfoBefore.scrollTop}px, Height: ${scrollInfoBefore.scrollHeight}px`);
+  
+  await performScroll(page);
+  
+  const scrollInfoAfter = await getScrollInfo(page);
+  console.log(`[get_daily_linkedin_connections] After scroll - Top: ${scrollInfoAfter.scrollTop}px, Height: ${scrollInfoAfter.scrollHeight}px`);
+  
+  return {
+    scrolled: scrollInfoAfter.scrollTop > scrollInfoBefore.scrollTop,
+    heightIncreased: scrollInfoAfter.scrollHeight > scrollInfoBefore.scrollHeight
+  };
+}
+
+async function performScroll(page) {
+  try {
+    console.log('[get_daily_linkedin_connections] Scrolling main element...');
     
-    console.log(`[get_daily_linkedin_connections] Before scroll - Top: ${scrollInfoBefore.scrollTop}px, Height: ${scrollInfoBefore.scrollHeight}px`);
+    const mainElement = await page.locator('main').first();
+    const containerExists = await mainElement.count();
     
-    try {
-      console.log('[get_daily_linkedin_connections] Scrolling main element...');
-      
-      const mainElement = await page.locator('main').first();
-      const containerExists = await mainElement.count();
-      
-      if (containerExists > 0) {
-        await mainElement.evaluate(function(el) {
-          console.log('Main element found, scrolling...');
-          console.log('Main scrollHeight:', el.scrollHeight);
-          console.log('Main clientHeight:', el.clientHeight);
-          console.log('Main scrollTop before:', el.scrollTop);
-          
-          el.scrollBy({ top: 2000, behavior: 'smooth' });
-          
-          console.log('Main scrollTop after:', el.scrollTop);
-        });
+    if (containerExists > 0) {
+      await mainElement.evaluate(function(el) {
+        console.log('Main element found, scrolling...');
+        console.log('Main scrollHeight:', el.scrollHeight);
+        console.log('Main clientHeight:', el.clientHeight);
+        console.log('Main scrollTop before:', el.scrollTop);
         
-        console.log('[get_daily_linkedin_connections] Scroll completed');
-      } else {
-        console.log('[get_daily_linkedin_connections] Main element not found');
-      }
-      console.log('[get_daily_linkedin_connections] Waiting for content to load...');
-      await new Promise(resolve => setTimeout(resolve, 3000));
-    } catch (e) {
-      console.log(`[get_daily_linkedin_connections] Scroll failed: ${e.message}`);
-      console.log('Stack trace:', e.stack);
+        el.scrollBy({ top: SCROLL_AMOUNT, behavior: 'smooth' });
+        
+        console.log('Main scrollTop after:', el.scrollTop);
+      });
+      
+      console.log('[get_daily_linkedin_connections] Scroll completed');
+    } else {
+      console.log('[get_daily_linkedin_connections] Main element not found');
     }
     
-    const scrollInfoAfter = await getScrollInfo(page);
-    
-    console.log(`[get_daily_linkedin_connections] After scroll - Top: ${scrollInfoAfter.scrollTop}px, Height: ${scrollInfoAfter.scrollHeight}px`);
-    
-    const scrolled = scrollInfoAfter.scrollTop > scrollInfoBefore.scrollTop;
-    const heightIncreased = scrollInfoAfter.scrollHeight > scrollInfoBefore.scrollHeight;
+    console.log('[get_daily_linkedin_connections] Waiting for content to load...');
+    await new Promise(resolve => setTimeout(resolve, SCROLL_WAIT_TIME));
+  } catch (e) {
+    console.log(`[get_daily_linkedin_connections] Scroll failed: ${e.message}`);
+    console.log('Stack trace:', e.stack);
+  }
+}
+
+async function updateScrollState(scrollState, scrollProgress) {
+  if (scrollProgress.scrolled || scrollProgress.heightIncreased) {
+    console.log('[get_daily_linkedin_connections] Page scrolled or expanded, continuing...');
+    scrollState.noScrollAttempts = 0;
+  } else {
+    scrollState.noScrollAttempts++;
+    console.log(`[get_daily_linkedin_connections] No scroll detected (attempt ${scrollState.noScrollAttempts}/${MAX_NO_SCROLL_ATTEMPTS})`);
     
-    if (scrolled || heightIncreased) {
-      console.log('[get_daily_linkedin_connections] Page scrolled or expanded, continuing...');
-      noScrollAttempts = 0; 
+    if (scrollState.noScrollAttempts >= MAX_NO_SCROLL_ATTEMPTS) {
+      console.log('[get_daily_linkedin_connections] Max attempts reached, stopping scroll');
+      scrollState.shouldStop = true;
     } else {
-      noScrollAttempts++;
-      console.log(`[get_daily_linkedin_connections] No scroll detected (attempt ${noScrollAttempts}/${maxNoScrollAttempts})`);
-      
-      if (noScrollAttempts < maxNoScrollAttempts) {
-        console.log('[get_daily_linkedin_connections] Waiting 5 seconds and trying again...');
-        await new Promise(resolve => setTimeout(resolve, 5000));
-      } else {
-        console.log('[get_daily_linkedin_connections] Max attempts reached, stopping scroll');
-        shouldStopScrolling = true;
-      }
+      console.log('[get_daily_linkedin_connections] Waiting 5 seconds and trying again...');
+      await new Promise(resolve => setTimeout(resolve, RETRY_WAIT_TIME));
     }
   }
+}
+
+function filterNewConnections(allConnections, lastCheckTimestamp) {
+  if (!lastCheckTimestamp) {
+    return allConnections;
+  }
   
-  const allConnections = Array.from(allConnectionsMap.values());
-  
-  const newConnections = allConnections.filter(conn => {
-    return !lastCheckTimestamp || (conn.connectionTimestamp && conn.connectionTimestamp >= lastCheckTimestamp);
-  });
-  
+  return allConnections.filter(conn => 
+    conn.connectionTimestamp && conn.connectionTimestamp >= lastCheckTimestamp
+  );
+}
+
+function createResult(totalConnections, newConnections, lastCheckTimestamp, currentTimestamp) {
   return {
     action: 'get_daily_linkedin_connections',
     result: {
@@ -118,7 +179,7 @@ export async function executeGetDailyLinkedInConnections(page, action) {
       newConnections: newConnections,
       newConnectionsCount: newConnections.length,
       lastCheckTimestamp: lastCheckTimestamp,
-      currentTimestamp: now
+      currentTimestamp: currentTimestamp
     },
     status: 'success'
   };