linkedin-automation-cli 1.0.0

package/src/linkedin/profile.test.ts

@@ -0,0 +1,79 @@
+// src/linkedin/profile.test.ts
+import { describe, it, expect } from 'vitest';
+import {
+  LinkedInProfile,
+  validateProfileUrl,
+  parseDurationString,
+  calculateTotalExperience,
+} from './profile';
+
+describe('LinkedInProfile', () => {
+  it('should be defined', () => {
+    expect(LinkedInProfile).toBeDefined();
+  });
+});
+
+describe('validateProfileUrl', () => {
+  it('should accept valid LinkedIn profile URLs', () => {
+    const validUrls = [
+      'https://www.linkedin.com/in/johndoe/',
+      'https://linkedin.com/in/jane-doe-123/',
+      'http://www.linkedin.com/in/user',
+    ];
+    validUrls.forEach((url) => {
+      expect(validateProfileUrl(url)).toBe(true);
+    });
+  });
+
+  it('should reject invalid URLs', () => {
+    const invalidUrls = [
+      'https://www.google.com/',
+      'https://linkedin.com/company/test',
+      'not-a-url',
+      '',
+    ];
+    invalidUrls.forEach((url) => {
+      expect(validateProfileUrl(url)).toBe(false);
+    });
+  });
+});
+
+describe('parseDurationString', () => {
+  it('should parse "Present" duration', () => {
+    const result = parseDurationString('Jan 2020 - Present (5 yrs 3 mos)');
+    expect(result).not.toBeNull();
+    expect(result!.years).toBe(5);
+    expect(result!.endDate).toBeNull();
+  });
+
+  it('should parse range duration', () => {
+    const result = parseDurationString('Mar 2019 - Dec 2021 (2 yr 10 mos)');
+    expect(result).not.toBeNull();
+    expect(result!.years).toBe(2);
+  });
+
+  it('should parse year-only duration', () => {
+    const result = parseDurationString('2018 - 2022 (4 years)');
+    expect(result).not.toBeNull();
+    expect(result!.years).toBe(4);
+  });
+
+  it('should return null for invalid duration', () => {
+    expect(parseDurationString('invalid')).toBeNull();
+    expect(parseDurationString('')).toBeNull();
+  });
+});
+
+describe('calculateTotalExperience', () => {
+  it('should sum years from durations', () => {
+    const durations = [
+      { startDate: new Date(), endDate: null, years: 5 },
+      { startDate: new Date(), endDate: new Date(), years: 3 },
+    ];
+    expect(calculateTotalExperience(durations)).toBe(8);
+  });
+
+  it('should return 0 for empty array', () => {
+    expect(calculateTotalExperience([])).toBe(0);
+  });
+});

package/src/linkedin/profile.ts

@@ -0,0 +1,314 @@
+// src/linkedin/profile.ts
+import type { Page } from 'playwright';
+import { SelectorEngine } from './selector-engine';
+import { SELECTORS } from './selectors';
+import type { ProfileData, ProfileExtractionOptions, ProfileExtractionResult } from '../types';
+
+// ============================================================================
+// URL Validation
+// ============================================================================
+
+const LINKEDIN_PROFILE_URL_REGEX = /^https?:\/\/(?:www\.)?linkedin\.com\/in\/[^\/]+\/?$/;
+
+export function validateProfileUrl(url: string): boolean {
+  return LINKEDIN_PROFILE_URL_REGEX.test(url);
+}
+
+// ============================================================================
+// Duration Parsing
+// ============================================================================
+
+interface ParsedDuration {
+  startDate: Date;
+  endDate: Date | null;
+  years: number;
+}
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+function parseMonthYear(text: string): Date {
+  const parts = text.trim().split(/\s+/);
+  const monthName = parts[0];
+  const year = parseInt(parts[1], 10);
+  const month = MONTHS.indexOf(monthName);
+  return new Date(year, month, 1);
+}
+
+export function parseDurationString(durationText: string): ParsedDuration | null {
+  if (!durationText || durationText.trim().length === 0) {
+    return null;
+  }
+
+  const text = durationText.trim();
+
+  // Pattern: "Jan 2020 - Present · 5 yrs 3 mos" or "Jan 2020 - Present (5 yrs 3 mos)"
+  const presentPattern =
+    /^(\w+\s+\d{4})\s*-\s*Present\s*[·(]\s*(\d+)\s*yrs?\s*(?:\d+\s*mos?)?\s*[·)]?$/i;
+  // Pattern: "Mar 2019 - Dec 2021 · 2 yr 10 mos" or with parentheses
+  const rangePattern =
+    /^(\w+\s+\d{4})\s*-\s*(\w+\s+\d{4})\s*[·(]\s*(\d+)\s*(?:yrs?|years?)\s*(?:\d+\s*mos?)?\s*[·)]?$/i;
+  // Pattern: "2018 - 2022 · 4 years" or with parentheses
+  const yearOnlyPattern = /^(\d{4})\s*-\s*(\d{4})\s*[·(]\s*(\d+)\s*years?\s*[·)]?$/i;
+
+  let match = text.match(presentPattern);
+  if (match) {
+    const startDate = parseMonthYear(match[1]);
+    const years = parseInt(match[2], 10);
+    return { startDate, endDate: null, years };
+  }
+
+  match = text.match(rangePattern);
+  if (match) {
+    const startDate = parseMonthYear(match[1]);
+    const endDate = parseMonthYear(match[2]);
+    const years = parseInt(match[3], 10);
+    return { startDate, endDate, years };
+  }
+
+  match = text.match(yearOnlyPattern);
+  if (match) {
+    const startDate = new Date(parseInt(match[1], 10), 0, 1);
+    const endDate = new Date(parseInt(match[2], 10), 11, 31);
+    const years = parseInt(match[3], 10);
+    return { startDate, endDate, years };
+  }
+
+  return null;
+}
+
+export function calculateTotalExperience(durations: ParsedDuration[]): number {
+  return durations.reduce((total, d) => total + d.years, 0);
+}
+
+// ============================================================================
+// LinkedInProfile Class
+// ============================================================================
+
+/**
+ * LinkedInProfile class for extracting structured data from LinkedIn profiles.
+ * Uses SelectorEngine with multi-layer fallbacks for resilience.
+ */
+export class LinkedInProfile {
+  private page: Page;
+  private selectorEngine: SelectorEngine;
+
+  constructor(page: Page) {
+    this.page = page;
+    this.selectorEngine = new SelectorEngine(page);
+  }
+
+  /**
+   * Extract profile data from a LinkedIn profile URL.
+   */
+  async extract(options: ProfileExtractionOptions): Promise<ProfileExtractionResult> {
+    const timeout = options.timeout ?? 30000;
+
+    // Validate URL
+    if (!validateProfileUrl(options.profileUrl)) {
+      return {
+        success: false,
+        message: 'Invalid LinkedIn profile URL',
+        error: 'URL must match pattern: https://www.linkedin.com/in/{username}/',
+      };
+    }
+
+    try {
+      // Navigate to profile
+      await this.page.goto(options.profileUrl, {
+        waitUntil: 'domcontentloaded',
+        timeout,
+      });
+      await this.page.waitForTimeout(3000);
+
+      // Extract top card data
+      const fullName = await this.extractText('profile', 'name');
+      if (!fullName) {
+        return {
+          success: false,
+          message: 'Could not extract profile name',
+          error: 'Profile name not found on page',
+        };
+      }
+
+      const headline = await this.extractText('profile', 'headline');
+      const location = await this.extractText('profile', 'location');
+
+      // Extract experience data
+      const experienceData = await this.extractExperienceData();
+
+      // Extract contact info if requested
+      let email: string | null = null;
+      let phone: string | null = null;
+      if (options.includeContact) {
+        const contactInfo = await this.extractContactInfo();
+        email = contactInfo.email;
+        phone = contactInfo.phone;
+      }
+
+      const profileData: ProfileData = {
+        full_name: fullName,
+        headline: headline ?? '',
+        location: location ?? '',
+        current_company: experienceData.currentCompany,
+        current_title: experienceData.currentTitle,
+        company_linkedin_url: experienceData.companyUrl,
+        years_experience: experienceData.yearsExperience,
+        email,
+        phone,
+        profile_url: this.page.url(),
+      };
+
+      return {
+        success: true,
+        message: 'Profile extracted successfully',
+        data: profileData,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        success: false,
+        message: errorMessage,
+        error: errorMessage,
+      };
+    }
+  }
+
+  /**
+   * Extract text using selector engine with fallbacks
+   */
+  private async extractText(
+    category: 'profile',
+    key: keyof typeof SELECTORS.profile
+  ): Promise<string | null> {
+    const result = await this.selectorEngine.findElement(category, key, { timeout: 5000 });
+    if (!result.element) {
+      return null;
+    }
+    const text = await result.element.textContent();
+    return text?.trim() || null;
+  }
+
+  /**
+   * Extract experience data from the profile
+   */
+  private async extractExperienceData(): Promise<{
+    currentCompany: string | null;
+    currentTitle: string | null;
+    companyUrl: string | null;
+    yearsExperience: number | null;
+  }> {
+    // Find experience section by looking for section with "Experience" heading
+    const expSection = await this.page.locator('section:has(h2:has-text("Experience"))').first();
+    const sectionCount = await expSection.count();
+    if (sectionCount === 0) {
+      return { currentCompany: null, currentTitle: null, companyUrl: null, yearsExperience: null };
+    }
+
+    // Get first experience item (li within the section)
+    const firstItem = expSection.locator('li').first();
+    const itemCount = await firstItem.count();
+    if (itemCount === 0) {
+      return { currentCompany: null, currentTitle: null, companyUrl: null, yearsExperience: null };
+    }
+
+    // Extract title from .t-bold span
+    let currentTitle: string | null = null;
+    try {
+      const titleEl = firstItem.locator('.t-bold span[aria-hidden="true"]').first();
+      const titleText = await titleEl.textContent({ timeout: 2000 });
+      if (titleText?.trim()) {
+        currentTitle = titleText.trim();
+      }
+    } catch {
+      // Title not found
+    }
+
+    // Extract company from .t-14.t-normal span
+    // Format is typically "Company Name · Full-time" or just "Company Name"
+    let currentCompany: string | null = null;
+    try {
+      const companyEls = firstItem.locator('.t-14.t-normal span[aria-hidden="true"]');
+      const count = await companyEls.count();
+      for (let i = 0; i < count; i++) {
+        const text = await companyEls.nth(i).textContent();
+        if (text?.trim()) {
+          // Skip duration patterns (contain month abbreviations or years)
+          if (text.includes('Present') || /\d{4}/.test(text)) continue;
+          // Extract company name from "Company · Employment Type" format
+          const companyText = text.split('·')[0].trim();
+          if (companyText && !companyText.includes('yrs') && !companyText.includes('mos')) {
+            currentCompany = companyText;
+            break;
+          }
+        }
+      }
+    } catch {
+      // Company not found
+    }
+
+    // Extract company URL
+    let companyUrl: string | null = null;
+    try {
+      const linkEl = firstItem.locator('a[data-field="experience_company_logo"]').first();
+      companyUrl = await linkEl.getAttribute('href', { timeout: 2000 });
+    } catch {
+      // Company link not found
+    }
+
+    // Extract duration for years calculation
+    // Duration format: "Dec 2025 - Present · 4 mos" or "Jan 2020 - Present · 5 yrs 3 mos"
+    let yearsExperience: number | null = null;
+    try {
+      const durationEl = firstItem.locator('.pvs-entity__caption-wrapper').first();
+      const durationText = await durationEl.textContent({ timeout: 2000 });
+      if (durationText) {
+        // Parse "X yrs Y mos" or just "X mos" format
+        const yrsMatch = durationText.match(/(\d+)\s*yrs?/i);
+        const mosMatch = durationText.match(/(\d+)\s*mos?/i);
+        if (yrsMatch) {
+          yearsExperience = parseInt(yrsMatch[1], 10);
+        } else if (mosMatch) {
+          // Convert months to fractional years
+          yearsExperience = Math.round((parseInt(mosMatch[1], 10) / 12) * 10) / 10;
+        }
+      }
+    } catch {
+      // Duration not found
+    }
+
+    return { currentCompany, currentTitle, companyUrl, yearsExperience };
+  }
+
+  /**
+   * Extract contact info by clicking the contact info button
+   */
+  private async extractContactInfo(): Promise<{ email: string | null; phone: string | null }> {
+    // Click contact info button
+    const buttonResult = await this.selectorEngine.findElement('profile', 'contactInfoButton', {
+      timeout: 5000,
+    });
+    if (!buttonResult.element) {
+      return { email: null, phone: null };
+    }
+
+    await buttonResult.element.click();
+    await this.page.waitForTimeout(2000);
+
+    // Extract email and phone
+    const email = await this.extractText('profile', 'email');
+    const phone = await this.extractText('profile', 'phone');
+
+    // Close modal
+    const closeResult = await this.selectorEngine.findElement('profile', 'contactInfoCloseButton', {
+      timeout: 2000,
+    });
+    if (closeResult.element) {
+      await closeResult.element.click();
+    } else {
+      await this.page.keyboard.press('Escape');
+    }
+    await this.page.waitForTimeout(1000);
+
+    return { email, phone };
+  }
+}

package/src/linkedin/reply.ts

@@ -0,0 +1,96 @@
+import type { Page } from 'playwright';
+import { SelectorEngine } from './selector-engine';
+
+export interface SendMessageOptions {
+  threadId: string;
+  text: string;
+  dryRun?: boolean;
+}
+
+export interface SendMessageResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+export class LinkedInReply {
+  private page: Page;
+  private selectorEngine: SelectorEngine;
+
+  constructor(page: Page) {
+    this.page = page;
+    this.selectorEngine = new SelectorEngine(page);
+  }
+
+  /**
+   * Send a message to a thread
+   */
+  async sendMessage(options: SendMessageOptions): Promise<SendMessageResult> {
+    try {
+      // Navigate to thread
+      await this.page.goto(`https://www.linkedin.com/messaging/thread/${options.threadId}/`, {
+        waitUntil: 'networkidle',
+        timeout: 30000,
+      });
+
+      // Wait for message input
+      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 message
+      await inputResult.element.fill(options.text);
+
+      // Check if dry run
+      if (options.dryRun) {
+        return {
+          success: true,
+          messageId: `dry-run-${Date.now()}`,
+        };
+      }
+
+      // 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 (look for confirmation)
+      await this.page.waitForTimeout(1000);
+
+      // Try to get message ID from the DOM
+      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,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error sending message',
+      };
+    }
+  }
+}

package/src/linkedin/selector-engine.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+
+// Mock Page object for testing - updated for current implementation
+const createMockPage = () => {
+  const mockElementHandle = { dispose: vi.fn() };
+  const getByRoleMock = vi.fn().mockReturnValue({
+    elementHandle: vi.fn().mockResolvedValue(mockElementHandle),
+  });
+  const getByLabelMock = vi.fn().mockReturnValue({
+    elementHandle: vi.fn().mockResolvedValue(mockElementHandle),
+  });
+  const getByTestIdMock = vi.fn().mockReturnValue({
+    elementHandle: vi.fn().mockResolvedValue(mockElementHandle),
+  });
+
+  return {
+    waitForSelector: vi.fn(),
+    $: vi.fn(),
+    $$: vi.fn(),
+    getByRole: getByRoleMock,
+    getByLabel: getByLabelMock,
+    getByTestId: getByTestIdMock,
+    _mockElementHandle: mockElementHandle,
+  };
+};
+
+type MockPage = ReturnType<typeof createMockPage>;
+
+// Import after creating mocks
+import { SelectorEngine } from './selector-engine';
+
+describe('SelectorEngine', () => {
+  let page: MockPage;
+  let engine: SelectorEngine;
+
+  beforeEach(() => {
+    page = createMockPage();
+    engine = new SelectorEngine(page as any);
+  });
+
+  describe('findElement', () => {
+    it('should return element when accessibility query succeeds', async () => {
+      const mockElement = { dispose: vi.fn() };
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockResolvedValue(mockElement),
+      });
+
+      const result = await engine.findElement('messages', 'conversationList', { timeout: 1000 });
+
+      expect(result.element).toBe(mockElement);
+      expect(result.selector).toBeTruthy();
+    });
+
+    it('should return null when no selectors match', async () => {
+      // Mock all accessibility methods to return null
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+      (page.getByLabel as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+      (page.getByTestId as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+
+      const result = await engine.findElement('messages', 'conversationList', { timeout: 1000 });
+
+      expect(result.element).toBeNull();
+      expect(result.selector).toBeNull();
+      expect(result.attempts.length).toBeGreaterThan(0);
+    });
+
+    it('should use visible state when requested', async () => {
+      const mockElement = { dispose: vi.fn() };
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockResolvedValue(mockElement),
+      });
+
+      await engine.findElement('messages', 'conversationList', {
+        timeout: 1000,
+        visible: true,
+      });
+
+      // Verify getByRole was called (accessibility-first approach)
+      expect(page.getByRole).toHaveBeenCalled();
+    });
+  });
+
+  describe('hasElement', () => {
+    it('should return true when element exists', async () => {
+      const mockElement = { dispose: vi.fn() };
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockResolvedValue(mockElement),
+      });
+
+      const result = await engine.hasElement('messages', 'conversationList');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when element does not exist', async () => {
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+      (page.getByLabel as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+      (page.getByTestId as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockRejectedValue(new Error('Not found')),
+      });
+
+      const result = await engine.hasElement('messages', 'conversationList');
+
+      expect(result).toBe(false);
+    });
+
+    it('should try multiple accessibility queries', async () => {
+      const mockElement = { dispose: vi.fn() };
+
+      // Mock getByRole to succeed
+      (page.getByRole as Mock).mockReturnValue({
+        elementHandle: vi.fn().mockResolvedValue(mockElement),
+      });
+
+      const result = await engine.hasElement('messages', 'conversationList');
+
+      expect(result).toBe(true);
+      expect(page.getByRole).toHaveBeenCalled();
+    });
+  });
+
+  describe('findAccessible', () => {
+    it('should find element by role and name', async () => {
+      const mockElement = { dispose: vi.fn() };
+      (page.waitForSelector as Mock).mockResolvedValue(mockElement);
+
+      const result = await engine.findAccessible({
+        role: 'button',
+        name: 'Submit',
+      });
+
+      expect(result).toBe(mockElement);
+    });
+
+    it('should find element by label', async () => {
+      const mockElement = { dispose: vi.fn() };
+      (page.waitForSelector as Mock).mockResolvedValue(mockElement);
+
+      const result = await engine.findAccessible({
+        label: 'Email address',
+      });
+
+      expect(result).toBe(mockElement);
+    });
+
+    it('should return null when no accessible element found', async () => {
+      (page.waitForSelector as Mock).mockRejectedValue(new Error('Not found'));
+
+      const result = await engine.findAccessible({
+        role: 'button',
+        name: 'NonExistent',
+      });
+
+      expect(result).toBeNull();
+    });
+  });
+});