linkedin-automation-cli 1.0.0

package/src/linkedin/company-extractor.ts

@@ -0,0 +1,222 @@
+/**
+ * Company Profile Extractor
+ *
+ * Extracts structured data from LinkedIn company profile pages.
+ * No authentication required - company pages are public.
+ */
+
+import type { Page } from 'playwright';
+import type { CompanyProfile } from '../types';
+import { SELECTORS } from './selectors';
+
+/** URL pattern for valid LinkedIn company pages */
+const COMPANY_URL_PATTERN = /^https:\/\/www\.linkedin\.com\/company\/[^\/]+\/?$/;
+
+/**
+ * Validate if a URL is a valid LinkedIn company URL
+ */
+export function isValidCompanyUrl(url: string): boolean {
+  return COMPANY_URL_PATTERN.test(url);
+}
+
+/**
+ * Parse follower count string to number
+ * Handles formats like "2.5M followers", "12K", "1,234"
+ */
+export function parseFollowerCount(text: string | null): number | null {
+  if (!text) return null;
+
+  // Extract numeric part with optional K/M suffix
+  const match = text.match(/([\d,.]+)\s*([KMkm]?)/);
+  if (!match) return null;
+
+  let num = parseFloat(match[1].replace(/,/g, ''));
+  const suffix = match[2].toUpperCase();
+
+  if (suffix === 'K') num *= 1000;
+  else if (suffix === 'M') num *= 1000000;
+
+  return Math.round(num);
+}
+
+/**
+ * Parse specialties string to array
+ * Splits by comma and trims whitespace
+ */
+export function parseSpecialties(text: string | null): string[] | null {
+  if (!text) return null;
+
+  const specialties = text
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+
+  return specialties.length > 0 ? specialties : null;
+}
+
+/**
+ * Extract definition list data by matching dt text to dd value
+ */
+async function extractDefinitionList(page: Page): Promise<Map<string, string>> {
+  const result = new Map<string, string>();
+
+  try {
+    const dts = await page.locator('dt').all();
+    const dds = await page.locator('dd').all();
+
+    for (let i = 0; i < Math.min(dts.length, dds.length); i++) {
+      const dtText = (await dts[i].textContent())?.trim() || '';
+      const ddText = (await dds[i].textContent())?.trim() || '';
+      if (dtText && ddText) {
+        result.set(dtText.toLowerCase(), ddText);
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return result;
+}
+
+/**
+ * Extract href from a link element using selector fallbacks
+ */
+async function extractHref(page: Page, selectors: readonly string[]): Promise<string | null> {
+  for (const selector of selectors) {
+    try {
+      const element = page.locator(selector).first();
+      const href = await element.getAttribute('href', { timeout: 2000 });
+      if (href?.trim()) {
+        return href.trim();
+      }
+    } catch {
+      // Try next selector
+    }
+  }
+  return null;
+}
+
+/**
+ * Dismiss authwall popup if present
+ */
+async function dismissAuthwall(page: Page): Promise<void> {
+  const selectors = SELECTORS.company.dismissAuthwall;
+
+  for (const selector of selectors) {
+    try {
+      const btn = page.locator(selector).first();
+      if (await btn.isVisible({ timeout: 1000 })) {
+        await btn.click();
+        await page.waitForTimeout(500);
+        return;
+      }
+    } catch {
+      // Try next selector
+    }
+  }
+}
+
+/**
+ * Company Profile Extractor
+ *
+ * Extracts structured data from LinkedIn company profile pages.
+ */
+export class CompanyExtractor {
+  constructor(private page: Page) {}
+
+  /**
+   * Extract company profile data from a LinkedIn company URL
+   */
+  async extract(url: string): Promise<CompanyProfile> {
+    // Navigate to company page with forced reload
+    await this.page.goto(url, {
+      waitUntil: 'domcontentloaded',
+      timeout: 30000,
+    });
+
+    // Force reload to ensure fresh content (helps with CDP connections)
+    await this.page.reload({ waitUntil: 'domcontentloaded', timeout: 30000 });
+
+    // Wait for page to load
+    await this.page.waitForTimeout(5000);
+
+    // Dismiss authwall popup if present
+    await dismissAuthwall(this.page);
+
+    // Wait additional time for dynamic content
+    await this.page.waitForTimeout(2000);
+
+    // Wait for about section to load (dt/dd elements)
+    try {
+      await this.page.waitForSelector('dt', { timeout: 10000 });
+    } catch {
+      // Continue anyway
+    }
+
+    // Extract definition list data (dt/dd pairs)
+    const definitions = await extractDefinitionList(this.page);
+
+    // Extract name from top card (clean up whitespace)
+    const rawName = await this.page.locator('h1').first().textContent({ timeout: 5000 });
+    const name = rawName?.trim().replace(/\s+/g, ' ') || '';
+
+    // Extract website from definition list (first link in dd)
+    let website: string | null = null;
+    try {
+      const websiteLink = this.page.locator('dt:has-text("Website") + dd a').first();
+      website = await websiteLink.getAttribute('href', { timeout: 2000 });
+    } catch {
+      // Try alternative selector
+      website = await extractHref(this.page, SELECTORS.company.website);
+    }
+
+    // Extract from definition list
+    const industry = definitions.get('industry') || null;
+    const company_size = definitions.get('company size') || definitions.get('employees') || null;
+    const headquarters = definitions.get('headquarters') || null;
+    const founded = definitions.get('founded') || null;
+    const specialtiesRaw = definitions.get('specialties') || null;
+    const type = definitions.get('company type') || definitions.get('type') || null;
+
+    // Extract follower count from top card
+    let followerRaw: string | null = null;
+    try {
+      // Look for text containing "followers"
+      const followerText = await this.page
+        .locator('.org-top-card-summary__followers, span.org-top-card-summary__followers')
+        .first()
+        .textContent({ timeout: 3000 });
+      followerRaw = followerText;
+    } catch {
+      // Fallback: look for any span with "followers" text
+      try {
+        const spans = await this.page.locator('span').all();
+        for (const span of spans) {
+          const text = await span.textContent();
+          if (text && text.toLowerCase().includes('followers')) {
+            followerRaw = text;
+            break;
+          }
+        }
+      } catch {
+        // Ignore
+      }
+    }
+
+    // Build profile object
+    const profile: CompanyProfile = {
+      name: name || '',
+      linkedin_url: url,
+      website,
+      industry,
+      company_size,
+      headquarters,
+      founded,
+      specialties: parseSpecialties(specialtiesRaw),
+      type,
+      follower_count: parseFollowerCount(followerRaw),
+    };
+
+    return profile;
+  }
+}

package/src/linkedin/connector.ts

@@ -0,0 +1,336 @@
+import type { BrowserController } from '../core/browser';
+import { SELECTORS } from './selectors';
+
+export interface ConnectionResult {
+  success: boolean;
+  error?: string;
+  sent?: boolean;
+  pending?: boolean;
+}
+
+export interface ConnectionOptions {
+  profileUrl: string;
+  note?: string;
+  skipNote?: boolean;
+}
+
+/**
+ * LinkedInConnector handles sending connection requests to LinkedIn profiles.
+ * It supports both direct Connect buttons and Connect options within the More menu.
+ */
+export class LinkedInConnector {
+  private browser: BrowserController;
+
+  constructor(browser: BrowserController) {
+    this.browser = browser;
+  }
+
+  /**
+   * Main method to send a connection request to a LinkedIn profile.
+   * Handles navigation, finding the connect button, adding notes, and sending.
+   */
+  async connect(options: ConnectionOptions): Promise<ConnectionResult> {
+    const page = this.browser.getPage();
+    if (!page) {
+      return { success: false, error: 'Browser not initialized' };
+    }
+
+    try {
+      // Navigate to profile
+      console.log(`Navigating to profile: ${options.profileUrl}`);
+      await page.goto(options.profileUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
+      await page.waitForTimeout(5000);
+
+      // Check current connection status
+      const status = await this.checkConnectionStatus();
+      console.log(`Connection status: ${status}`);
+
+      if (status === 'connected') {
+        return { success: true, sent: false, pending: false, error: 'Already connected' };
+      }
+
+      if (status === 'pending') {
+        return {
+          success: true,
+          sent: false,
+          pending: true,
+          error: 'Connection request already pending',
+        };
+      }
+
+      // Find and click the connect button
+      const connectButton = await this.findConnectButton();
+      if (!connectButton) {
+        return { success: false, error: 'Could not find Connect button' };
+      }
+
+      console.log(`Found connect button using selector: ${connectButton.selectorUsed}`);
+      // Use force click to avoid interception by other elements
+      await connectButton.element.click({ force: true });
+      console.log('Clicked Connect button, waiting for modal...');
+      await page.waitForTimeout(3000);
+
+      // Handle "Add a note" modal if note is provided
+      if (options.note && !options.skipNote) {
+        const addNoteResult = await this.findElementWithFallbacks(
+          SELECTORS.connection.addNoteButton,
+          'Add a note button'
+        );
+
+        if (addNoteResult) {
+          console.log('Clicking "Add a note" button');
+          await addNoteResult.click();
+          await page.waitForTimeout(500);
+
+          // Find and fill the note textarea
+          const noteTextareaResult = await this.findElementWithFallbacks(
+            SELECTORS.connection.noteTextarea,
+            'Note textarea'
+          );
+
+          if (noteTextareaResult) {
+            console.log('Adding note to connection request');
+            await noteTextareaResult.fill(options.note);
+            await page.waitForTimeout(500);
+          }
+        }
+      }
+
+      // Click the Send button
+      console.log('Looking for Send button in modal...');
+
+      // Wait a moment for the modal to fully render
+      await page.waitForTimeout(2000);
+
+      // Try to find Send button with multiple strategies
+      let sendButton = null;
+
+      // Strategy 1: Try primary button in modal
+      const modalButtons = await page.$$('.artdeco-modal button, [role="dialog"] button');
+      console.log(`Found ${modalButtons.length} buttons in modal/dialog`);
+
+      for (const button of modalButtons) {
+        const text = await button.textContent();
+        const ariaLabel = await button.getAttribute('aria-label');
+        const isPrimary = await button.evaluate(
+          (el) =>
+            el.classList.contains('artdeco-button--primary') || el.getAttribute('type') === 'submit'
+        );
+
+        console.log(`  Button: text="${text?.trim()}", aria="${ariaLabel}", primary=${isPrimary}`);
+
+        // Look for Send, Connect, or primary action button
+        if (
+          text?.match(/send|connect/i) ||
+          ariaLabel?.match(/send|connect/i) ||
+          (isPrimary && text?.length && text.length < 20)
+        ) {
+          sendButton = button;
+          console.log(`  -> Selected as send button`);
+          break;
+        }
+      }
+
+      // Strategy 2: Fallback to original selector-based approach
+      if (!sendButton) {
+        console.log('Falling back to selector-based approach...');
+        const sendButtonResult = await this.findElementWithFallbacks(
+          SELECTORS.connection.sendButton,
+          'Send button'
+        );
+        if (sendButtonResult) {
+          sendButton = sendButtonResult;
+        }
+      }
+
+      if (!sendButton) {
+        return { success: false, error: 'Could not find Send button' };
+      }
+
+      console.log('Clicking Send button');
+      await sendButton.click();
+      await page.waitForTimeout(2000);
+
+      // Verify the request was sent (check for success indicators or absence of error)
+      const errorMessage = await page.$(
+        '[role="alert"], .artdeco-inline-feedback--error, [data-testid="error-message"]'
+      );
+      if (errorMessage) {
+        const errorText = await errorMessage.textContent();
+        return { success: false, error: errorText || 'Unknown error occurred' };
+      }
+
+      return { success: true, sent: true, pending: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      console.error('Connection request failed:', errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * Finds the Connect button on a profile page.
+   * Tries direct Connect button first, then looks in the More actions menu.
+   * Returns the element and which selector was used, or null if not found.
+   */
+  async findConnectButton(): Promise<{
+    element: import('playwright').ElementHandle;
+    selectorUsed: string;
+  } | null> {
+    const page = this.browser.getPage();
+    if (!page) return null;
+
+    // First, try direct Connect button
+    console.log('Looking for direct Connect button...');
+    const directConnect = await this.findElementWithFallbacks(
+      SELECTORS.connection.connectButton,
+      'Connect button'
+    );
+
+    if (directConnect) {
+      console.log('Found direct Connect button');
+      return { element: directConnect, selectorUsed: 'direct-connect' };
+    }
+
+    // If no direct button, look for "More actions" menu
+    console.log('No direct Connect button found, looking for More actions menu...');
+    const moreActions = await this.findElementWithFallbacks(
+      SELECTORS.connection.moreActionsButton,
+      'More actions button'
+    );
+
+    if (!moreActions) {
+      console.log('Could not find More actions button');
+      return null;
+    }
+
+    // Click More actions to open dropdown
+    console.log('Clicking More actions button');
+    await moreActions.click();
+    await page.waitForTimeout(1000);
+
+    // Look for Connect option in the dropdown
+    console.log('Looking for Connect option in dropdown...');
+    const connectOption = await this.findElementWithFallbacks(
+      SELECTORS.connection.connectOptionInMenu,
+      'Connect option in menu'
+    );
+
+    if (connectOption) {
+      console.log('Found Connect option in dropdown');
+      return { element: connectOption, selectorUsed: 'more-menu' };
+    }
+
+    // Close the dropdown by pressing Escape
+    await page.keyboard.press('Escape');
+    await page.waitForTimeout(500);
+
+    console.log('Could not find Connect option in dropdown');
+    return null;
+  }
+
+  /**
+   * Checks the current connection status with a profile.
+   * Returns: 'connected', 'pending', 'none', or 'unknown'
+   */
+  async checkConnectionStatus(): Promise<'connected' | 'pending' | 'none' | 'unknown'> {
+    const page = this.browser.getPage();
+    if (!page) return 'unknown';
+
+    try {
+      // IMPORTANT: Check for Pending and Message FIRST, before looking for Connect buttons
+      // This avoids finding "Connect" buttons on other people's profiles in the sidebar
+      // when the actual profile status is "Pending" or "Connected"
+
+      // Check for "Pending" button/text (request already sent)
+      // LinkedIn shows "Pending" as a button when connection is pending
+      // IMPORTANT: Use a more specific selector that only matches in the main profile header
+      const pendingButton = await page.$('section.artdeco-card button:has-text("Pending")');
+      if (pendingButton) {
+        const isVisible = await pendingButton.isVisible().catch(() => false);
+        if (isVisible) {
+          return 'pending';
+        }
+      }
+
+      // Check for "Message" button (already connected)
+      // Only check in the main profile header, not dropdown menus
+      const messageButton = await page.$('section.artdeco-card button:has-text("Message")');
+      if (messageButton) {
+        const isVisible = await messageButton.isVisible().catch(() => false);
+        if (isVisible) {
+          return 'connected';
+        }
+      }
+
+      // Now check if there's a Connect button (meaning NOT connected)
+      const connectButton = await this.findElementWithFallbacks(
+        SELECTORS.connection.connectButton,
+        'Connect button for status check'
+      );
+      if (connectButton) {
+        return 'none'; // Can connect - not connected yet
+      }
+
+      // Check for "More" menu with Connect inside (also means NOT connected)
+      const moreActions = await this.findElementWithFallbacks(
+        SELECTORS.connection.moreActionsButton,
+        'More actions button for status check'
+      );
+      if (moreActions) {
+        // Check if there's a Connect option in the dropdown
+        await moreActions.click();
+        await page.waitForTimeout(500);
+
+        const connectOption = await this.findElementWithFallbacks(
+          SELECTORS.connection.connectOptionInMenu,
+          'Connect option in More menu'
+        );
+
+        // Close the dropdown
+        await page.keyboard.press('Escape');
+        await page.waitForTimeout(300);
+
+        if (connectOption) {
+          return 'none'; // Can connect via More menu
+        }
+      }
+
+      return 'unknown';
+    } catch (error) {
+      console.error('Error checking connection status:', error);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Helper method to try multiple selectors and return the first matching element.
+   * Logs which selector was used for debugging purposes.
+   */
+  private async findElementWithFallbacks(
+    selectors: readonly string[],
+    elementName: string
+  ): Promise<import('playwright').ElementHandle | null> {
+    const page = this.browser.getPage();
+    if (!page) return null;
+
+    for (const selector of selectors) {
+      try {
+        const element = await page.$(selector);
+        if (element) {
+          const isVisible = await element.isVisible().catch(() => false);
+          if (isVisible) {
+            console.log(`Found ${elementName} using selector: ${selector}`);
+            return element;
+          }
+          await element.dispose();
+        }
+      } catch {
+        // Continue to next selector
+      }
+    }
+
+    console.log(`Could not find ${elementName} with any selector`);
+    return null;
+  }
+}

package/src/linkedin/message-sender.ts

@@ -0,0 +1,141 @@
+import type { Page } from 'playwright';
+import { SelectorEngine } from './selector-engine';
+
+export interface SendMessageOptions {
+  profileUrl: string;
+  text: string;
+  dryRun?: boolean;
+}
+
+export interface SendMessageResult {
+  success: boolean;
+  messageId?: string;
+  threadId?: string;
+  error?: string;
+}
+
+export class LinkedInMessageSender {
+  private page: Page;
+  private selectorEngine: SelectorEngine;
+  private linkedInDomain: string = 'https://www.linkedin.com';
+
+  constructor(page: Page) {
+    this.page = page;
+    this.selectorEngine = new SelectorEngine(page);
+    // Always use linkedin.com for messaging (linkedin.cn has limited functionality)
+    // The browser session cookies will still work across domains
+  }
+
+  /**
+   * Send a message to a LinkedIn profile
+   */
+  async sendMessage(options: SendMessageOptions): Promise<SendMessageResult> {
+    try {
+      // Navigate to messaging page directly (works on both domains)
+      const messagingUrl = `${this.linkedInDomain}/messaging/`;
+      console.log(`Navigating to messaging page: ${messagingUrl}`);
+
+      await this.page.goto(messagingUrl, {
+        waitUntil: 'domcontentloaded',
+        timeout: 30000,
+      });
+
+      // Wait for page to load
+      await this.page.waitForTimeout(3000);
+
+      // Extract profile ID from URL
+      const profileId = this.extractProfileId(options.profileUrl);
+
+      // Navigate to compose URL with recipient
+      const composeUrl = `${this.linkedInDomain}/messaging/compose/?recipient=${profileId}`;
+      console.log(`Navigating to compose URL with recipient: ${profileId}`);
+
+      await this.page.goto(composeUrl, {
+        waitUntil: 'domcontentloaded',
+        timeout: 30000,
+      });
+
+      // Wait for message input to appear
+      await this.page.waitForTimeout(3000);
+
+      // Wait for message input field
+      const inputResult = await this.selectorEngine.findElement('messages', 'messageInput', {
+        timeout: 10000,
+        visible: true,
+      });
+
+      if (!inputResult.element) {
+        return { success: false, error: 'Could not find message input field' };
+      }
+
+      // Type the message
+      await inputResult.element.fill(options.text);
+
+      // Check if dry run
+      if (options.dryRun) {
+        return {
+          success: true,
+          messageId: `dry-run-${Date.now()}`,
+          threadId: this.extractThreadId(),
+        };
+      }
+
+      // Click send button
+      const sendResult = await this.selectorEngine.findElement('messages', 'sendButton', {
+        timeout: 5000,
+        visible: true,
+      });
+
+      if (!sendResult.element) {
+        return { success: false, error: 'Could not find send button' };
+      }
+
+      await sendResult.element.click();
+
+      // Wait for message to be sent
+      await this.page.waitForTimeout(1000);
+
+      // Try to get message ID
+      const messageId = await this.page.evaluate(() => {
+        const lastMessage = document.querySelector('[data-urn*="urn:li:fsd_message:"]');
+        if (lastMessage) {
+          const urn = lastMessage.getAttribute('data-urn');
+          if (urn) {
+            const match = urn.match(/urn:li:fsd_message:(\d+)/);
+            return match ? match[1] : urn;
+          }
+        }
+        return `msg-${Date.now()}`;
+      });
+
+      return {
+        success: true,
+        messageId,
+        threadId: this.extractThreadId(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error sending message',
+      };
+    }
+  }
+
+  /**
+   * Extract profile ID from LinkedIn profile URL
+   * e.g., https://www.linkedin.com/in/lily-q-7145971b9/ -> lily-q-7145971b9
+   */
+  private extractProfileId(profileUrl: string): string {
+    const match = profileUrl.match(/\/in\/([^/?]+)/);
+    return match ? match[1] : '';
+  }
+
+  /**
+   * Extract thread ID from current URL
+   */
+  private extractThreadId(): string | undefined {
+    const url = this.page.url();
+    const match = url.match(/\/messaging\/thread\/([^/]+)/);
+    return match ? match[1] : undefined;
+  }
+}