coffeeinabit 0.0.1

package/tools/comment_post.js

@@ -0,0 +1,88 @@
+export async function executeCommentPost(page, action) {
+  const postUrl = action.parameters?.url || action.url;
+  const commentText = action.parameters?.comment_text || action.comment_text;
+  
+  if (!postUrl || !commentText) {
+    throw new Error('Missing url or comment_text for comment_post');
+  }
+  
+  await page.goto(postUrl, {
+    waitUntil: 'domcontentloaded',
+    timeout: Math.floor(Math.random() * 20000) + 40000
+  });
+  
+  await page.waitForSelector('main', { timeout: 10000 });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 10000) + 500));
+  await page.evaluate(() => { window.scrollTo(0, document.body.scrollHeight / 2); });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 4000) + 500));
+  
+  let commentEditor = await page.locator('.comments-comment-box-comment__text-editor .ql-editor[contenteditable="true"]').first();
+  
+  if (await commentEditor.count() === 0) {
+    const altEditor = await page.locator('[data-test-ql-editor-contenteditable="true"]').first();
+    
+    if (await altEditor.count() === 0) {
+      return {
+        action: 'comment_post',
+        result: { status: 'not_found', message: `Could not find comment editor for post: ${postUrl}` },
+        status: 'failed'
+      };
+    }
+    
+    await altEditor.click();
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    await altEditor.fill(commentText);
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    
+    let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
+    
+    if (await submitButton.count() > 0) {
+      await submitButton.click();
+      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+    } else {
+      const altSubmitButton = await page.locator('button:has-text("Comment")').first();
+      
+      if (await altSubmitButton.count() > 0) {
+        await altSubmitButton.click();
+        await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      } else {
+        return {
+          action: 'comment_post',
+          result: { status: 'submit_not_found', message: `Could not find Comment submit button for post: ${postUrl}` },
+          status: 'failed'
+        };
+      }
+    }
+  } else {
+    await commentEditor.click();
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    await commentEditor.fill(commentText);
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    
+    let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
+    
+    if (await submitButton.count() > 0) {
+      await submitButton.click();
+      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+    } else {
+      const altSubmitButton = await page.locator('button:has-text("Comment")').first();
+      
+      if (await altSubmitButton.count() > 0) {
+        await altSubmitButton.click();
+        await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      } else {
+        return {
+          action: 'comment_post',
+          result: { status: 'submit_not_found', message: `Could not find Comment submit button for post: ${postUrl}` },
+          status: 'failed'
+        };
+      }
+    }
+  }
+  
+  return {
+    action: 'comment_post',
+    result: { status: 'success', message: `Comment successfully posted on post: ${postUrl}` },
+    status: 'success'
+  };
+}

package/tools/cookie_manager.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import path from 'path';
+
+export class CookieManager {
+  constructor() {
+    this.contextDir = path.join(process.cwd(), 'context');
+    this.ensureContextDir();
+  }
+
+  ensureContextDir() {
+    if (!fs.existsSync(this.contextDir)) {
+      fs.mkdirSync(this.contextDir, { recursive: true });
+    }
+  }
+
+  getCookieFilePath(userEmail) {
+    const sanitizedEmail = userEmail.replace(/[^a-zA-Z0-9]/g, '_');
+    return path.join(this.contextDir, `linkedin_cookies_${sanitizedEmail}.json`);
+  }
+
+  async saveCookies(userEmail, cookies) {
+    try {
+      const cookieFilePath = this.getCookieFilePath(userEmail);
+      const cookieData = {
+        userEmail: userEmail,
+        cookies: cookies,
+        savedAt: new Date().toISOString(),
+        expiresAt: this.calculateExpiryTime()
+      };
+
+      fs.writeFileSync(cookieFilePath, JSON.stringify(cookieData, null, 2));
+      console.log('[CookieManager] Cookies saved for:', userEmail);
+      return true;
+    } catch (error) {
+      console.error('[CookieManager] Error saving cookies:', error.message);
+      return false;
+    }
+  }
+
+  async loadCookies(userEmail) {
+    try {
+      const cookieFilePath = this.getCookieFilePath(userEmail);
+      
+      if (!fs.existsSync(cookieFilePath)) {
+        return null;
+      }
+
+      const cookieData = JSON.parse(fs.readFileSync(cookieFilePath, 'utf8'));
+      
+      if (this.isCookieDataExpired(cookieData)) {
+        this.deleteCookies(userEmail);
+        return null;
+      }
+
+      console.log('[CookieManager] Loaded cookies for:', userEmail);
+      return cookieData.cookies;
+    } catch (error) {
+      console.error('[CookieManager] Error loading cookies:', error.message);
+      return null;
+    }
+  }
+
+  async deleteCookies(userEmail) {
+    try {
+      const cookieFilePath = this.getCookieFilePath(userEmail);
+      if (fs.existsSync(cookieFilePath)) {
+        fs.unlinkSync(cookieFilePath);
+      }
+      return true;
+    } catch (error) {
+      console.error('[CookieManager] Error deleting cookies:', error.message);
+      return false;
+    }
+  }
+
+  async setCookiesInContext(context, cookies) {
+    try {
+      if (!cookies || cookies.length === 0) {
+        return false;
+      }
+
+      await context.addCookies(cookies);
+      return true;
+    } catch (error) {
+      console.error('[CookieManager] Error setting cookies in context:', error.message);
+      return false;
+    }
+  }
+
+  async verifyAuthentication(context) {
+    try {
+      const page = await context.newPage();
+      
+      await page.goto('https://www.linkedin.com/feed/', {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+      });
+
+      const currentUrl = page.url();
+      const isAuthenticated = currentUrl.includes('/feed') && !currentUrl.includes('/login');
+      
+      return { isAuthenticated, page };
+    } catch (error) {
+      console.error('[CookieManager] Error verifying authentication:', error.message);
+      return { isAuthenticated: false, page: null };
+    }
+  }
+
+  calculateExpiryTime() {
+    const now = new Date();
+    const expiryTime = new Date(now.getTime() + (7 * 24 * 60 * 60 * 1000));
+    return expiryTime.toISOString();
+  }
+
+  isCookieDataExpired(cookieData) {
+    if (!cookieData.expiresAt) {
+      return true;
+    }
+    
+    const now = new Date();
+    const expiryTime = new Date(cookieData.expiresAt);
+    return now > expiryTime;
+  }
+
+  async getCookieInfo(userEmail) {
+    try {
+      const cookieFilePath = this.getCookieFilePath(userEmail);
+      
+      if (!fs.existsSync(cookieFilePath)) {
+        return null;
+      }
+
+      const cookieData = JSON.parse(fs.readFileSync(cookieFilePath, 'utf8'));
+      return {
+        userEmail: cookieData.userEmail,
+        savedAt: cookieData.savedAt,
+        expiresAt: cookieData.expiresAt,
+        isExpired: this.isCookieDataExpired(cookieData),
+        cookieCount: cookieData.cookies ? cookieData.cookies.length : 0
+      };
+    } catch (error) {
+      console.error('[CookieManager] Error getting cookie info:', error.message);
+      return null;
+    }
+  }
+}
+
+export default CookieManager;

package/tools/get_daily_linkedin_connections.js

@@ -0,0 +1,86 @@
+export async function executeGetDailyLinkedInConnections(page, action) {
+  const lastCheckTimestamp = action.parameters?.last_check_timestamp
+    ? parseInt(action.parameters.last_check_timestamp, 10)
+    : null;
+  
+  const url = 'https://www.linkedin.com/mynetwork/invite-connect/connections/';
+  await page.goto(url, {
+    waitUntil: 'domcontentloaded',
+    timeout: 60000
+  });
+  
+  await page.waitForSelector('a[href*="/in/"]', { 
+    timeout: Math.floor(Math.random() * 5000) + 5000 
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+  
+  const totalConnections = await page.evaluate(() => {
+    const headerElement = document.querySelector('h1');
+    if (headerElement) {
+      const match = headerElement.textContent.match(/(\d+)\s+Connections?/i);
+      return match ? parseInt(match[1]) : 0;
+    }
+    return 0;
+  });
+  
+  const now = Date.now();
+  const newConnections = await page.evaluate(({ lastCheckTimestamp, now }) => {
+    function parseConnectionDate(str) {
+      if (!str) return null;
+      const match = str.match(/Connected on (.+)/i);
+      if (!match) return null;
+      const dateStr = match[1].trim();
+      try {
+        const timestamp = new Date(dateStr).getTime();
+        return isNaN(timestamp) ? null : timestamp;
+      } catch (e) {
+        return null;
+      }
+    }
+    
+    const connections = [];
+    const allParagraphs = document.querySelectorAll('p');
+    
+    allParagraphs.forEach(p => {
+      const text = p.textContent.trim();
+      if (text.startsWith('Connected on')) {
+        const parentDiv = p.parentElement;
+        if (parentDiv) {
+          const profileLink = parentDiv.querySelector('a[href*="/in/"]');
+          if (profileLink) {
+            const href = profileLink.getAttribute('href');
+            const usernameMatch = href.match(/\/in\/([^/?]+)/);
+            if (usernameMatch) {
+              const username = usernameMatch[1];
+              const connectionDate = text;
+              const connectionTimestamp = parseConnectionDate(connectionDate);
+              
+              if (!lastCheckTimestamp || (connectionTimestamp && connectionTimestamp >= lastCheckTimestamp)) {
+                connections.push({
+                  username: username,
+                  connectionDate: connectionDate,
+                  connectionTimestamp: connectionTimestamp
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+    
+    return connections;
+  }, { lastCheckTimestamp, now });
+  
+  return {
+    action: 'get_daily_linkedin_connections',
+    result: {
+      totalConnections: totalConnections,
+      newConnections: newConnections,
+      newConnectionsCount: newConnections.length,
+      lastCheckTimestamp: lastCheckTimestamp,
+      currentTimestamp: now
+    },
+    status: 'success'
+  };
+}

package/tools/get_linkedin_search_results.js

@@ -0,0 +1,141 @@
+export async function executeLinkedInSearch(page, action) {
+  const linkedinUrl = action.parameters?.url || action.url;
+  const maxPages = action.parameters?.max_pages || 10;
+  
+  if (!linkedinUrl) {
+    throw new Error('Missing url for get_linkedin_search_results');
+  }
+  
+  let navigationSuccess = true;
+  try {
+    await page.goto(linkedinUrl, {
+      waitUntil: 'load',
+      timeout: Math.floor(Math.random() * 20000) + 10000
+    });
+  } catch (error) {
+    navigationSuccess = false;
+  }
+  
+  let searchResults = [];
+  let currentPage = 1;
+  let isLastPage = false;
+  let title = '';
+  
+  while (!isLastPage && currentPage <= Math.min(maxPages, 10)) {
+    if (!navigationSuccess) {
+      break;
+    }
+    
+    try {
+      await page.waitForLoadState('domcontentloaded', { timeout: 10000 });
+    } catch (error) {
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 10000) + 500));
+    
+    let htmlContent = await page.content();
+    let pageResults;
+    
+    try {
+      title = await page.title();
+      const listItems = await page.locator('ul[role="list"] li').all();
+      
+      if (listItems.length > 0) {
+        const firstItem = listItems[0];
+        const firstItemHTML = await firstItem.innerHTML().catch(() => '');
+        console.log('[LinkedInSearch] First item HTML structure:', firstItemHTML.substring(0, 500));
+      } else {
+        console.log('[LinkedInSearch] No list items found');
+        break;
+      }
+      
+      const pageSearchResults = await parseLinkedInSearchResultsFromHTML(htmlContent);
+      
+      pageResults = pageSearchResults;
+    } catch (error) {
+      pageResults = [];
+    }
+    
+    searchResults.push(...pageResults);
+    
+    currentPage++;
+    let nextUrl = linkedinUrl.includes('?') 
+      ? linkedinUrl + '&page=' + currentPage
+      : linkedinUrl + '?page=' + currentPage;
+    
+    try {
+      await page.goto(nextUrl, {
+        waitUntil: 'load',
+        timeout: Math.floor(Math.random() * 20000) + 10000
+      });
+      navigationSuccess = true;
+    } catch (error) {
+      navigationSuccess = false;
+      break;
+    }
+  }
+  
+  return {
+    action: 'get_linkedin_search_results',
+    result: {
+      title: title,
+      results: searchResults,
+      url: linkedinUrl,
+      searchResultsCount: searchResults.length,
+      pagesProcessed: currentPage,
+      last_page: isLastPage
+    },
+    status: 'success'
+  };
+}
+
+async function parseLinkedInSearchResultsFromHTML(htmlContent) {
+  try {
+    const results = [];
+    
+    const listItemPattern = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+    const linkPattern = /<a[^>]*href="([^"]*\/in\/[^"]*)"[^>]*>/gi;
+    
+    let listItemMatch;
+    
+    while ((listItemMatch = listItemPattern.exec(htmlContent)) !== null) {
+      const listItemHtml = listItemMatch[1];
+      
+      const linkMatches = [];
+      let linkMatch;
+      
+      while ((linkMatch = linkPattern.exec(listItemHtml)) !== null) {
+        linkMatches.push(linkMatch[1]);
+      }
+      
+      if (linkMatches.length > 0) {
+        const href = linkMatches[0];
+        let username = '';
+        
+        if (href) {
+          const usernameMatch = href.match(/\/in\/([^/?]+)/);
+          if (usernameMatch) {
+            username = usernameMatch[1];
+          }
+        }
+        
+        const textContent = listItemHtml
+          .replace(/<[^>]*>/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim();
+        
+        results.push({
+          link: href,
+          username: username,
+          item: textContent
+        });
+      }
+    }
+    
+    return results;
+    
+  } catch (error) {
+    console.error('[LinkedInSearch] Error parsing search results:', error);
+    return [];
+  }
+}

package/tools/get_linkedin_updates.js

@@ -0,0 +1,51 @@
+import { executeGetDailyLinkedInConnections } from './get_daily_linkedin_connections.js';
+import { executeGetNewMessages } from './get_new_messages.js';
+
+export async function executeGetLinkedInUpdates(page, action, accessToken) {
+  try {
+    console.log('[GetLinkedInUpdates] Starting unified updates check...');
+    
+    const lastChecked = action.parameters?.last_checked || 0;
+    
+    console.log('[GetLinkedInUpdates] Fetching new messages...');
+    const messagesResult = await executeGetNewMessages(page, action, accessToken);
+    
+    console.log('[GetLinkedInUpdates] Waiting before fetching connections...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    console.log('[GetLinkedInUpdates] Fetching new connections...');
+    const connectionsAction = {
+      action: 'get_daily_linkedin_connections',
+      parameters: {
+        last_check_timestamp: lastChecked
+      }
+    };
+    const connectionsResult = await executeGetDailyLinkedInConnections(page, connectionsAction);
+    
+    console.log('[GetLinkedInUpdates] Connections result:', JSON.stringify(connectionsResult, null, 2));
+    console.log('[GetLinkedInUpdates] Messages result:', JSON.stringify(messagesResult, null, 2));
+    
+    const results = {
+      newConnections: connectionsResult.result?.newConnections || [],
+      newConnectionsCount: connectionsResult.result?.newConnectionsCount || 0,
+      totalConnections: connectionsResult.result?.totalConnections || 0,
+      newMessages: messagesResult.messages || []
+    };
+
+    console.log('[GetLinkedInUpdates] Unified results:', {
+      newConnectionsCount: results.newConnectionsCount,
+      newConnectionsArray: results.newConnections.length,
+      totalConnections: results.totalConnections,
+      newMessagesCount: results.newMessages.length
+    });
+
+    return {
+      action: 'get_linkedin_updates',
+      result: results,
+      status: 'success'
+    };
+  } catch (error) {
+    console.error('[GetLinkedInUpdates] Error:', error.message);
+    throw error;
+  }
+}

package/tools/get_messages.js

@@ -0,0 +1,92 @@
+export async function executeGetMessages(page, action) {
+  const username = action.parameters?.username || action.username;
+  
+  if (!username) {
+    throw new Error('Missing username for get_messages');
+  }
+  
+  const profileUrl = `https://www.linkedin.com/in/${username}`;
+  await page.goto(profileUrl, {
+    waitUntil: 'load',
+    timeout: Math.floor(Math.random() * 20000) + 40000
+  });
+  
+  await page.waitForLoadState('domcontentloaded');
+  
+  const pendingButton = await getButtonByText(page, 'Pending', true);
+  if (pendingButton) {
+    return {
+      action: 'get_messages',
+      result: { status: 'connection_request_pending', message: `Connection request pending for ${username}. Not connected` },
+      status: 'pending'
+    };
+  }
+  
+  const clicked = await page.evaluate(() => {
+    const buttons = Array.from(document.querySelectorAll('.artdeco-button--primary'));
+    console.log('found buttons: ', buttons);
+    const messageBtn = buttons.find(btn =>
+      btn.textContent.includes('Message') && btn.offsetParent !== null
+    );
+    if (messageBtn) {
+      messageBtn.click();
+      return true;
+    }
+    console.log('no messageBtn found');
+    return false;
+  });
+  
+  if (!clicked) {
+    return {
+      action: 'get_messages',
+      result: { status: 'not_connected', message: `Could not find Message button on ${username}'s profile. This usually means you are not connected with this user on LinkedIn. You can only retrieve messages from users who are in your connections.` },
+      status: 'failed'
+    };
+  }
+  
+  await page.waitForSelector('.msg-overlay-conversation-bubble__content-wrapper', { timeout: 10000 });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+  
+  await page.evaluate(() => {
+    const wrapper = document.querySelector('.msg-overlay-conversation-bubble__content-wrapper');
+    if (wrapper) {
+      wrapper.scrollTo(0, 0);
+    }
+  });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+  
+  const content = await page.evaluate(() => {
+    const wrapper = document.querySelector('.msg-overlay-conversation-bubble__content-wrapper');
+    return wrapper ? wrapper.innerText : '';
+  });
+  
+  return {
+    action: 'get_messages',
+    result: { status: 'success', message: content },
+    status: 'success'
+  };
+}
+
+async function getButtonByText(page, text, inMain = false) {
+  let buttons = [];
+  if (inMain) {
+    buttons = await page.locator('main button').all();
+  } else {
+    buttons = await page.locator('button').all();
+  }
+  
+  for (const button of buttons) {
+    try {
+      const buttonText = await button.textContent();
+      if (buttonText && buttonText.includes(text)) {
+        const isVisible = await button.isVisible();
+        if (isVisible) {
+          return button;
+        }
+      }
+    } catch (error) {
+    }
+  }
+  
+  return null;
+}