coffeeinabit 0.0.1

package/tools/human_typing.js

@@ -0,0 +1,32 @@
+export async function humanLikeType(element, text) {
+  for (const char of text) {
+    await element.type(char, { delay: 0 });
+    
+    const delay = Math.floor(Math.random() * 100) + 50;
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+  
+  const finalDelay = Math.floor(Math.random() * 300) + 200;
+  await new Promise(resolve => setTimeout(resolve, finalDelay));
+}
+
+export async function readLinkedInCredentials() {
+  const fs = (await import('fs')).default;
+  const path = (await import('path')).default;
+  
+  const credentialsPath = path.join(process.cwd(), 'credentials', 'linkedin.json');
+  
+  if (!fs.existsSync(credentialsPath)) {
+    throw new Error(`Credentials file not found at: ${credentialsPath}. Please create it with your LinkedIn email and password.`);
+  }
+  
+  const credentialsData = fs.readFileSync(credentialsPath, 'utf-8');
+  const credentials = JSON.parse(credentialsData);
+  
+  if (!credentials.email || !credentials.password) {
+    throw new Error('Credentials file must contain "email" and "password" fields');
+  }
+  
+  return credentials;
+}
+

package/tools/like_post.js

@@ -0,0 +1,57 @@
+export async function executeLikePost(page, action) {
+  const postUrl = action.parameters?.url || action.url;
+  
+  if (!postUrl) {
+    throw new Error('Missing url for like_post');
+  }
+  
+  await page.goto(postUrl, {
+    waitUntil: 'domcontentloaded',
+    timeout: 60000
+  });
+  
+  await page.waitForSelector('main', { timeout: Math.floor(Math.random() * 5000) + 5000 });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 3000) + 500));
+  
+  let likeButton = await page.locator('main button[aria-label="React Like"], main button[aria-label="Unreact Like"]').first();
+  
+  if (await likeButton.count() === 0) {
+    likeButton = await page.locator('main button:has-text("Like"), main button:has-text("Unlike")').first();
+  }
+  
+  if (await likeButton.count() > 0) {
+    const ariaLabel = await likeButton.getAttribute('aria-label');
+    
+    if (ariaLabel === 'Unreact Like') {
+      return {
+        action: 'like_post',
+        result: { status: 'already_liked', message: `Post is already liked: ${postUrl}` },
+        status: 'success'
+      };
+    } else if (ariaLabel === 'React Like') {
+      await page.evaluate((button) => { 
+        if (button) button.click(); 
+      }, await likeButton.elementHandle());
+      
+      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      
+      return {
+        action: 'like_post',
+        result: { status: 'liked', message: `Post liked successfully: ${postUrl}` },
+        status: 'success'
+      };
+    } else {
+      return {
+        action: 'like_post',
+        result: { status: 'unknown', message: `Could not determine Like button state for post: ${postUrl}` },
+        status: 'failed'
+      };
+    }
+  } else {
+    return {
+      action: 'like_post',
+      result: { status: 'not_found', message: `Could not find Like button for post: ${postUrl}` },
+      status: 'failed'
+    };
+  }
+}

package/tools/send_connection_request.js

@@ -0,0 +1,155 @@
+export async function executeSendConnectionRequest(page, action) {
+  let username = action.parameters?.username;
+  if (!username) {
+    throw new Error('Missing username for send_connection_request');
+  }
+
+  try {
+    const profileUrl = `https://www.linkedin.com/in/${username}`;
+    await page.goto(profileUrl, {
+      waitUntil: 'load',
+      timeout: 60000
+    });
+
+    await page.waitForLoadState('load');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    await page.evaluate(() => { window.scrollTo(0, 300); });
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+
+    return await detectConnectionStatus(page, username);
+
+  } catch (error) {
+    console.error('[SendConnectionRequest] Error:', error.message);
+    throw error;
+  }
+}
+
+async function detectConnectionStatus(page, username) {
+  let inMain = true;
+  
+  const connectResult = await handleConnectButtonClick(page, username, inMain, true);
+  if (connectResult.status === 'success') {
+    return connectResult;
+  }
+
+  let moreActionsSelectors = await getButtonByText(page, 'More', inMain);
+  if (!moreActionsSelectors || !(await moreActionsSelectors.isVisible())) {
+    moreActionsSelectors = await getButtonByText(page, 'More actions', inMain);
+  }
+  if (moreActionsSelectors && (await moreActionsSelectors.isVisible())) {
+    await moreActionsSelectors.click();
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+  }
+  let removeConnectionButton = await getButtonByText(page, 'Remove Connection', inMain);
+  if (!removeConnectionButton) {
+    removeConnectionButton = await getButtonByText(page, 'Remove', inMain);
+  }
+  if (!removeConnectionButton) {
+    removeConnectionButton = await getButtonByText(page, 'Connected', inMain);
+  }
+  if (removeConnectionButton) {
+    return { status: 'already_connected', message: `Already connected with ${username}.` };
+  }
+  
+  const connectResultWithNote = await handleConnectButtonClick(page, username, inMain, true);
+  if (connectResultWithNote.status === 'success') {
+    return connectResultWithNote;
+  }
+  let sentConnectionButton = await getButtonByText(page, 'Sent connection', inMain);
+  if (!sentConnectionButton) {
+    sentConnectionButton = await getButtonByText(page, 'Pending', inMain);
+  }
+  if (!sentConnectionButton) {
+    sentConnectionButton = await getButtonByText(page, 'Invitation sent', inMain);
+  }
+  if (sentConnectionButton) {
+    return { status: 'pending', message: `Connection request already pending for ${username}.` };
+  }
+  
+  return { 
+    status: 'not_found', 
+    message: `Could not find Connect button for ${username}. Please analyze dom and decide what to do next.` 
+  };
+}
+
+async function handleConnectButtonClick(page, username, inMain = true, handleSendWithoutNote = true) {
+  let connectButton = await getButtonByText(page, 'Connect', inMain);
+  if (!connectButton || !(await connectButton.isVisible())) {
+    connectButton = await getButtonByText(page, 'Connect', inMain);
+  }
+
+  if (connectButton && (await connectButton.isVisible())) {
+    try {
+      await connectButton.click();
+      
+      if (handleSendWithoutNote) {
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        let sendWithoutNoteButton = await getButtonByText(page, 'Send without a note', false);
+        if (!sendWithoutNoteButton) {
+          sendWithoutNoteButton = await getButtonByText(page, 'without a note', false);
+        }
+        if (!sendWithoutNoteButton) {
+          sendWithoutNoteButton = await getButtonByText(page, 'Send', false);
+        }
+        
+        if (sendWithoutNoteButton && (await sendWithoutNoteButton.isVisible())) {
+          try {
+            await sendWithoutNoteButton.click();
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return { status: 'success', message: `Connection request sent successfully to ${username}` };
+          } catch (error) {
+            return { status: 'unclear', message: `Error clicking Send without a note button for ${username}` };
+          }
+        } else {
+          const existingModal = await page.locator('[data-test-modal-id="send-invite-modal"]').isVisible();
+          if (existingModal) {
+            return { status: 'success', message: `Modal already open for ${username}` };
+          } else {
+            return { status: 'unclear', message: `No send without a note button found for ${username}` };
+          }
+        }
+      } else {
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        return { status: 'success', message: `Connection request sent successfully to ${username}` };
+      }
+    } catch (error) {
+      return { status: 'error', message: `Error clicking Connect button for ${username}: ${error.message}` };
+    }
+  }
+  
+  return { status: 'not_found', message: `Connect button not found for ${username}` };
+}
+
+async function getButtonByText(page, text, inMain = false) {
+  let buttons = [];
+  
+  if (inMain) {
+    const mainContent = page.locator('main');
+    buttons = await mainContent.locator('button').all();
+    const spans = await page.locator('div[role="button"] span').all();
+    buttons = [...buttons, ...spans];
+  } else {
+    buttons = await page.locator('button').all();
+    const spans = await page.locator('div[role="button"] span').all();
+    buttons = [...buttons, ...spans];
+  }
+
+  for (let i = 0; i < buttons.length; i++) {
+    const button = buttons[i];
+    try {
+      if (!(await button.isVisible())) {
+        continue;
+      }
+      const buttonText = await button.textContent() || await button.innerText() || '';
+      if (buttonText.trim() === text) {
+        return button;
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  
+  return null;
+}

package/tools/send_messages.js

@@ -0,0 +1,162 @@
+export async function executeSendMessages(page, action) {
+  const username = action.parameters?.username || action.username;
+  let messages = action.parameters?.messages || action.messages;
+  
+  if (!username || !messages) {
+    throw new Error('Missing username or messages for send_messages');
+  }
+  
+  if (typeof messages === 'string') {
+    messages = [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');
+  await page.evaluate(() => { window.scrollTo(0, 300); });
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+  
+  await closeAllConversationBubbles(page);
+  
+  const messageBtn = await getButtonByText(page, 'Message', true);
+  if (!messageBtn) {
+    return {
+      action: 'send_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.` },
+      status: 'failed'
+    };
+  }
+  
+  try {
+    await messageBtn.click();
+  } catch (error) {
+    return {
+      action: 'send_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.` },
+      status: 'failed'
+    };
+  }
+  
+  await findAndClickMessageInput(page);
+  
+  for (const message of messages) {
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 100) + 500));
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    await typeLikeHuman(page, message);
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 500) + 500));
+    
+    const clickedSend = await clickSendButton(page);
+    if (!clickedSend) {
+      return {
+        action: 'send_messages',
+        result: { status: 'send_button_not_found', message: 'Could not find send button.' },
+        status: 'failed'
+      };
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+  }
+  
+  await closeAllConversationBubbles(page);
+  
+  return {
+    action: 'send_messages',
+    result: { status: 'success', message: `Message successfully sent to ${username}` },
+    status: 'success'
+  };
+}
+
+async function typeLikeHuman(page, text) {
+  for (const char of text) {
+    await page.keyboard.type(char);
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 100) + 50));
+  }
+}
+
+async function findAndClickMessageInput(page) {
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  const editorClicked = await page.evaluate(() => {
+    const editor = document.querySelector('.msg-form__contenteditable[contenteditable="true"]');
+    if (editor) {
+      editor.focus();
+      return true;
+    }
+    return false;
+  });
+  
+  if (editorClicked) {
+    await new Promise(resolve => setTimeout(resolve, 500));
+    return;
+  }
+  
+  const placeholderClicked = await page.evaluate(() => {
+    const placeholder = document.querySelector('.msg-form__placeholder');
+    if (placeholder) {
+      placeholder.click();
+      return true;
+    }
+    return false;
+  });
+  
+  if (placeholderClicked) {
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+}
+
+async function closeAllConversationBubbles(page) {
+  await page.evaluate(() => {
+    const closeButtons = document.querySelectorAll('.msg-overlay-bubble-header__control--new-convo-btn');
+    closeButtons.forEach(btn => {
+      try {
+        btn.click();
+      } catch (e) {
+      }
+    });
+  });
+  await new Promise(resolve => setTimeout(resolve, 500));
+}
+
+async function clickSendButton(page) {
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  const clicked = await page.evaluate(() => {
+    const sendButton = document.querySelector('.msg-form__send-button:not([disabled])');
+    if (sendButton) {
+      sendButton.click();
+      return true;
+    }
+    return false;
+  });
+  
+  return clicked;
+}
+
+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;
+}