linkedin-automation-cli 1.0.0

package/src/linkedin/messages.ts

@@ -0,0 +1,894 @@
+import type { Page, ElementHandle } from 'playwright';
+import type { Message, Thread } from '../types';
+import { SelectorEngine } from './selector-engine';
+import { SELECTORS } from './selectors';
+import type { BrowserController } from '../core/browser';
+
+export interface MessageListOptions {
+  limit?: number;
+  unreadOnly?: boolean;
+}
+
+export interface ThreadOptions {
+  threadId: string;
+  limit?: number;
+}
+
+export class LinkedInMessages {
+  private page: Page;
+  private selectorEngine: SelectorEngine;
+
+  constructor(page: Page, _browser?: BrowserController) {
+    this.page = page;
+    this.selectorEngine = new SelectorEngine(page);
+  }
+
+  /**
+   * Navigate to LinkedIn messaging page
+   */
+  async navigateToMessages(): Promise<void> {
+    await this.page.goto('https://www.linkedin.com/messaging/', {
+      waitUntil: 'domcontentloaded',
+      timeout: 10000,
+    });
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * Get list of conversation threads
+   */
+  async getThreads(options: MessageListOptions = {}): Promise<Thread[]> {
+    // Navigation is now handled by the caller - we're already on the messaging page
+
+    const limit = options.limit ?? 20;
+    const threads: Thread[] = [];
+
+    // Wait for conversation list to load
+    const listResult = await this.selectorEngine.findElement('messages', 'conversationList', {
+      timeout: 10000,
+    });
+
+    if (!listResult.element) {
+      console.warn('Could not find conversation list');
+      return threads;
+    }
+
+    // Get all conversation items using Playwright locators (more reliable than CSS selectors)
+    // LinkedIn uses dynamic class names, so we use multiple strategies
+
+    // Strategy 1: Look for li elements with msg-conversation-listitem class (the actual list items)
+    const listItems = await this.page.$$('[class*="msg-conversation-listitem"]');
+
+    // Get the conversation card div inside each list item
+    let conversationItems: ElementHandle[] = [];
+    for (const listItem of listItems) {
+      const card = await listItem.$('.msg-conversation-card');
+      if (card) {
+        conversationItems.push(card);
+      }
+    }
+
+    // Strategy 2: Try data-testid
+    if (conversationItems.length === 0) {
+      conversationItems = await this.page.$$('[data-testid="conversation-card"]');
+    }
+
+    // Strategy 3: Try by ID pattern (conversation-card-ember*)
+    if (conversationItems.length === 0) {
+      conversationItems = await this.page.$$('[id^="conversation-card-"]');
+    }
+
+    // Strategy 4: Try role-based listitem query
+    if (conversationItems.length === 0) {
+      const allListItems = await this.page.$$('[role="listitem"]');
+      for (const item of allListItems) {
+        const text = await item.evaluate((el) => el.textContent || '');
+        // Conversation cards typically have participant names and message previews
+        if (text.length > 5 && (text.includes(':') || text.match(/\d+[mhd]/))) {
+          conversationItems.push(item);
+        }
+      }
+    }
+
+    // Final fallback: get all children of the conversation list that look like cards
+    if (conversationItems.length === 0 && listResult.element) {
+      const allChildren = await listResult.element.$$('* > *');
+      for (const child of allChildren) {
+        const className = await child.evaluate((el) => {
+          // Handle both SVG and HTML elements
+          if ('className' in el && typeof el.className === 'string') {
+            return el.className;
+          }
+          // For SVG elements, className might be an object
+          if ('className' in el && el.className && 'baseVal' in el.className) {
+            return (el.className as any).baseVal;
+          }
+          return '';
+        });
+        // LinkedIn conversation cards typically have specific patterns
+        if (
+          className &&
+          (className.includes('msg-') ||
+            className.includes('conversation') ||
+            className.includes('artdeco'))
+        ) {
+          conversationItems.push(child);
+        }
+      }
+    }
+
+    for (let i = 0; i < Math.min(conversationItems.length, limit); i++) {
+      const item = conversationItems[i];
+      const thread = await this.parseThreadItem(item);
+
+      if (thread) {
+        // Filter by unread if requested
+        if (options.unreadOnly && thread.unreadCount === 0) {
+          continue;
+        }
+        threads.push(thread);
+      }
+    }
+
+    return threads;
+  }
+
+  /**
+   * Parse a single conversation item element into a Thread
+   */
+  private async parseThreadItem(item: ElementHandle): Promise<Thread | null> {
+    try {
+      // Extract thread ID from data attribute or URL
+      const threadId = await item.evaluate((el) => {
+        const element = el as Element;
+
+        // Strategy 1: Try to get from data-conversation-urn attribute
+        const dataId = element.getAttribute('data-conversation-urn');
+        if (dataId) return dataId;
+
+        // Strategy 2: Try data-urn variant
+        const dataUrn = element.getAttribute('data-urn');
+        if (dataUrn) {
+          const match = dataUrn.match(/thread:(\d+)/);
+          if (match) return match[1];
+        }
+
+        // Strategy 3: Look for data-event-urn in descendants (contains thread ID)
+        // Format: urn:li:msg_message:(urn:li:fsd_profile:...,2-<threadId>)
+        const eventUrnEl = element.querySelector('[data-event-urn]');
+        if (eventUrnEl) {
+          const eventUrn = eventUrnEl.getAttribute('data-event-urn');
+          if (eventUrn) {
+            // Extract thread ID from format: urn:li:msg_message:(...,2-<base64id>)
+            const match = eventUrn.match(/,2-([A-Za-z0-9+/=]+)/);
+            if (match) {
+              return `2-${match[1]}`;
+            }
+          }
+        }
+
+        // Strategy 4: Try to extract from link inside the element
+        const link = element.querySelector('a[href*="/messaging/thread/"]');
+        if (link) {
+          const href = link.getAttribute('href');
+          if (href) {
+            const match = href.match(/\/messaging\/thread\/([^/]+)/);
+            if (match) return match[1];
+          }
+        }
+
+        // Strategy 5: Try to get from parent link
+        const parentLink = element.closest('a[href*="/messaging/thread/"]');
+        if (parentLink) {
+          const href = parentLink.getAttribute('href');
+          if (href) {
+            const match = href.match(/\/messaging\/thread\/([^/]+)/);
+            if (match) return match[1];
+          }
+        }
+
+        // Strategy 6: Extract from element ID (conversation-card-ember50 -> ember50)
+        const elemId = element.id;
+        if (elemId && elemId.includes('conversation-card')) {
+          // Use the ember ID as a fallback
+          return elemId.replace('conversation-card-', '');
+        }
+
+        return null;
+      });
+
+      if (!threadId) {
+        return null;
+      }
+
+      // Extract participant names using multiple selector strategies
+      const participantNames = await this.extractTextArrayFromElement(item, [
+        '.msg-conversation-card__participant-names',
+        '.msg-conversation-listitem__participant-names',
+        '[class*="participant-name"]',
+        '[class*="participant"]',
+      ]);
+
+      // Fallback: get participant name from image alt attribute
+      if (participantNames.length === 0) {
+        const imgAlt = await item.evaluate((el: Element) => {
+          const img = el.querySelector('img[alt]');
+          return img?.getAttribute('alt') || '';
+        });
+        if (imgAlt) {
+          participantNames.push(imgAlt);
+        }
+      }
+
+      // Extract last message preview
+      const lastMessageText = await this.extractTextFromElementSingle(item, [
+        '.msg-conversation-card__message-snippet',
+        '.msg-conversation-card__message-preview',
+        '.msg-conversation-listitem__message-preview',
+        '[class*="message-snippet"]',
+        '[class*="message-preview"]',
+        '[class*="last-message"]',
+      ]);
+
+      // Check for unread indicator using multiple strategies
+      const hasUnread = await this.checkForUnreadIndicator(item);
+
+      // Get timestamp if available
+      const timestampText = await this.extractTextFromElementSingle(item, [
+        'time',
+        '[class*="timestamp"]',
+        '[class*="time"]',
+      ]);
+
+      // Also try to get timestamp from datetime attribute
+      let lastActivity: Date;
+      const datetimeAttr = await item.evaluate((el: Element) => {
+        const timeEl = el.querySelector('time');
+        return timeEl?.getAttribute('datetime') || null;
+      });
+
+      if (datetimeAttr) {
+        lastActivity = new Date(datetimeAttr);
+      } else if (timestampText) {
+        lastActivity = this.parseRelativeTimestamp(timestampText);
+      } else {
+        lastActivity = new Date();
+      }
+
+      // Create partial thread (without full messages)
+      const thread: Thread = {
+        id: threadId,
+        participants:
+          participantNames.length > 0
+            ? participantNames.map((name) => ({ name, profileUrl: undefined }))
+            : [{ name: 'Unknown', profileUrl: undefined }],
+        messages: [
+          {
+            id: `preview-${threadId}`,
+            threadId,
+            sender: { name: participantNames[0] || 'Unknown', isMe: false },
+            content: lastMessageText,
+            timestamp: lastActivity,
+            isRead: !hasUnread,
+          },
+        ],
+        lastActivity,
+        unreadCount: hasUnread ? 1 : 0,
+      };
+
+      return thread;
+    } catch (error) {
+      console.warn('Failed to parse thread item:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Extract multiple text values from an element - returns array of strings
+   */
+  private async extractTextArrayFromElement(
+    element: ElementHandle,
+    selectors: string[]
+  ): Promise<string[]> {
+    for (const selector of selectors) {
+      try {
+        const texts = await element.$$eval(selector, (els) =>
+          els.map((el) => el.textContent?.trim()).filter(Boolean)
+        );
+        if (texts.length > 0) return texts;
+      } catch {
+        // Try next selector
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Extract single text value from an element - returns string
+   */
+  private async extractTextFromElementSingle(
+    element: ElementHandle,
+    selectors: string[]
+  ): Promise<string> {
+    for (const selector of selectors) {
+      try {
+        const text = await element.$eval(selector, (el) => el.textContent?.trim() || '');
+        if (text) return text;
+      } catch {
+        // Try next selector
+      }
+    }
+    return '';
+  }
+
+  /**
+   * Check if a conversation item has unread messages
+   */
+  private async checkForUnreadIndicator(item: ElementHandle): Promise<boolean> {
+    // Check for unread indicator element
+    const selectors = [
+      '.msg-conversation-card__unread-indicator',
+      '.msg-conversation-listitem__unread-indicator',
+      '[class*="unread"]',
+    ];
+
+    for (const selector of selectors) {
+      try {
+        const unreadEl = await item.$(selector);
+        if (unreadEl) return true;
+      } catch {
+        // Continue
+      }
+    }
+
+    // Check for bold/heavy font weight (unread messages often have bold text)
+    const fontWeight = await item.evaluate((el: Element) => {
+      const nameEl =
+        el.querySelector('[class*="participant-name"]') ||
+        el.querySelector('[class*="conversation-card__title"]');
+      if (nameEl) {
+        const style = window.getComputedStyle(nameEl);
+        return parseInt(style.fontWeight) >= 600; // semibold or bold
+      }
+      return false;
+    });
+
+    return fontWeight;
+  }
+
+  /**
+   * Parse relative timestamps like "5m", "2h", "Yesterday"
+   */
+  private parseRelativeTimestamp(text: string): Date {
+    const trimmed = text.trim().toLowerCase();
+    const now = new Date();
+
+    // Match patterns like "5m", "2h", "3d", "1w"
+    const relativeMatch = trimmed.match(/^(\d+)([mhdw])$/);
+    if (relativeMatch) {
+      const value = parseInt(relativeMatch[1]);
+      const unit = relativeMatch[2];
+
+      switch (unit) {
+        case 'm':
+          return new Date(now.getTime() - value * 60 * 1000);
+        case 'h':
+          return new Date(now.getTime() - value * 60 * 60 * 1000);
+        case 'd':
+          return new Date(now.getTime() - value * 24 * 60 * 60 * 1000);
+        case 'w':
+          return new Date(now.getTime() - value * 7 * 24 * 60 * 60 * 1000);
+      }
+    }
+
+    // Check for "Yesterday"
+    if (trimmed === 'yesterday') {
+      return new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    }
+
+    // Fallback to current time
+    return now;
+  }
+
+  /**
+   * Get full thread with all messages
+   */
+  async getThread(options: ThreadOptions): Promise<Thread | null> {
+    const { threadId, limit = 50 } = options;
+
+    // Navigate to thread
+    await this.page.goto(`https://www.linkedin.com/messaging/thread/${threadId}/`, {
+      waitUntil: 'networkidle',
+      timeout: 30000,
+    });
+
+    // Wait for messages to load
+    const messagesResult = await this.selectorEngine.findElement('messages', 'messageBubble', {
+      timeout: 10000,
+    });
+
+    if (!messagesResult.element) {
+      console.warn('Could not find message bubbles');
+      return null;
+    }
+
+    // Get all message bubbles
+    const messageElements = await this.page.$$(SELECTORS.messages.messageBubble.join(', '));
+    const messages: Message[] = [];
+
+    for (let i = 0; i < Math.min(messageElements.length, limit); i++) {
+      const message = await this.parseMessage(
+        messageElements[i] as ElementHandle<HTMLElement>,
+        threadId
+      );
+      if (message) {
+        messages.push(message);
+      }
+    }
+
+    // Get participant info
+    const participants = await this.getThreadParticipants();
+
+    return {
+      id: threadId,
+      participants,
+      messages,
+      lastActivity: messages[messages.length - 1]?.timestamp || new Date(),
+      unreadCount: messages.filter((m) => !m.isRead).length,
+    };
+  }
+
+  /**
+   * Show a thread by clicking on a conversation card (for ember IDs) or direct navigation
+   * Returns the thread with messages, handling both ember IDs and real thread IDs
+   */
+  async showThread(threadId: string, limit: number = 50): Promise<Thread | null> {
+    // Check if this is an ember ID (e.g., "ember50") or a real thread ID
+    const isEmberId = threadId.startsWith('ember');
+
+    if (isEmberId) {
+      // Navigate to messaging page first
+      await this.navigateToMessages();
+
+      // Find and click the conversation card to get the real thread ID
+      const realThreadId = await this.clickAndGetThreadId(threadId);
+      if (!realThreadId) {
+        console.warn(`Could not find conversation card with ID: ${threadId}`);
+        return null;
+      }
+      threadId = realThreadId;
+    } else {
+      // Check if already on the correct thread URL
+      const currentUrl = this.page.url();
+      const targetUrl = `https://www.linkedin.com/messaging/thread/${threadId}/`;
+
+      if (!currentUrl.includes(threadId)) {
+        // Navigate directly to the thread
+        await this.page.goto(targetUrl, {
+          waitUntil: 'domcontentloaded',
+          timeout: 30000,
+        });
+      } else {
+        console.log('Already on correct thread URL');
+      }
+    }
+
+    // Wait for messages to load
+    await this.page.waitForTimeout(2000);
+
+    // Scrape messages
+    const messages = await this.scrapeMessages(threadId, limit);
+    const participants = await this.getThreadParticipants();
+
+    if (messages.length === 0) {
+      console.warn('No messages found in thread');
+      return null;
+    }
+
+    return {
+      id: threadId,
+      participants,
+      messages,
+      lastActivity: messages[messages.length - 1]?.timestamp || new Date(),
+      unreadCount: messages.filter((m) => !m.isRead).length,
+    };
+  }
+
+  /**
+   * Click on a conversation card and extract the real thread ID from the URL
+   */
+  private async clickAndGetThreadId(emberId: string): Promise<string | null> {
+    try {
+      // Wait for conversation list to load
+      await this.page.waitForTimeout(3000);
+
+      // Strategy 1: Try to find the card by ID
+      let card = await this.page.$(`#conversation-card-${emberId}`);
+
+      // Strategy 2: Find by index using msg-conversation-card class
+      if (!card) {
+        const listItems = await this.page.$$('[class*="msg-conversation-listitem"]');
+        let conversationCards: ElementHandle<HTMLElement>[] = [];
+
+        for (const listItem of listItems) {
+          const c = await listItem.$('.msg-conversation-card');
+          if (c) conversationCards.push(c as ElementHandle<HTMLElement>);
+        }
+
+        // Fallback to direct class match
+        if (conversationCards.length === 0) {
+          conversationCards = (await this.page.$$(
+            '.msg-conversation-card'
+          )) as ElementHandle<HTMLElement>[];
+        }
+
+        // The ember ID number (e.g., ember50 -> 50) doesn't match DOM position
+        // We need to find the card that has this ember ID in its element ID
+        const targetEmberNumber = emberId.replace('ember', '');
+        for (let i = 0; i < conversationCards.length; i++) {
+          const cardId = await conversationCards[i].evaluate((el: Element) => el.id);
+          if (cardId && cardId.includes(targetEmberNumber)) {
+            card = conversationCards[i];
+            break;
+          }
+        }
+
+        // If still not found, try using the first card as a test
+        if (!card && conversationCards.length > 0) {
+          card = conversationCards[0];
+        }
+      }
+
+      // Strategy 3: Try data-testid
+      if (!card) {
+        const cards = await this.page.$$('[data-testid="conversation-card"]');
+        const index = parseInt(emberId.replace('ember', ''));
+        if (!isNaN(index) && cards.length > index) {
+          card = cards[index] as ElementHandle<HTMLElement>;
+        }
+      }
+
+      if (!card) {
+        return null;
+      }
+
+      // Click the card - LinkedIn SPA doesn't trigger navigation event
+      await card.click();
+
+      // Wait for URL to change (SPA navigation)
+      await this.page.waitForTimeout(2000);
+
+      // Extract thread ID from the new URL
+      const currentUrl = this.page.url();
+      const match = currentUrl.match(/\/messaging\/thread\/([^/]+)/);
+      if (match) {
+        return match[1];
+      }
+
+      return null;
+    } catch (error) {
+      console.warn('Failed to click conversation card:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Scrape messages from a loaded thread page
+   */
+  private async scrapeMessages(threadId: string, limit: number = 50): Promise<Message[]> {
+    const messages: Message[] = [];
+
+    // Wait for messages to load
+    await this.page.waitForTimeout(3000);
+
+    // Look for actual message content in the conversation
+    // LinkedIn uses event list items for messages
+    const messageElements = (await this.page.$$(
+      '.msg-s-event-listitem'
+    )) as ElementHandle<HTMLElement>[];
+
+    for (const msgEl of messageElements) {
+      if (messages.length >= limit) break;
+
+      // Get sender name
+      const senderName = await msgEl
+        .$eval('.msg-s-message-group__name', (el) => el.textContent?.trim() || '')
+        .catch(() => '');
+
+      // Get timestamp
+      let timestamp = new Date();
+      const datetimeAttr = await msgEl
+        .$eval('time', (el) => el.getAttribute('datetime'))
+        .catch(() => null);
+      if (datetimeAttr) {
+        timestamp = new Date(datetimeAttr);
+      }
+
+      // Get message content
+      const content = await msgEl
+        .$eval(
+          '.msg-s-event-listitem__body, [class*="event-listitem__body"]',
+          (el) => el.textContent?.trim() || ''
+        )
+        .catch(() => '');
+
+      // Skip if no content
+      if (!content || content.length < 2) continue;
+
+      // Skip UI noise
+      if (
+        content.includes('Open Emoji Keyboard') ||
+        content.includes('Maximize compose') ||
+        content.includes('Send to') ||
+        content === 'Download'
+      ) {
+        continue;
+      }
+
+      // Check if from current user
+      const isMe = await msgEl.evaluate((el) => {
+        return (
+          el.classList.contains('msg-s-message-group--me') ||
+          el.classList.contains('sent') ||
+          el.closest('.msg-s-message-group--me') !== null
+        );
+      });
+
+      messages.push({
+        id: `msg-${threadId}-${messages.length}`,
+        threadId,
+        sender: {
+          name: senderName || (isMe ? 'You' : 'Unknown'),
+          isMe,
+        },
+        content,
+        timestamp,
+        isRead: true,
+      });
+    }
+
+    // If no messages found with event list items, try alternative approach
+    if (messages.length === 0) {
+      const messageContainers = (await this.page.$$(
+        '[class*="message"]'
+      )) as ElementHandle<HTMLElement>[];
+      const seenContent = new Set<string>();
+
+      for (const container of messageContainers) {
+        if (messages.length >= limit) break;
+
+        const content = await container.evaluate((el) => {
+          // Skip meta elements
+          if (
+            el.classList.contains('msg-s-message-group__meta') ||
+            el.classList.contains('msg-s-message-group__name') ||
+            el.classList.contains('msg-s-message-group__timestamp') ||
+            el.tagName.toLowerCase() === 'time'
+          ) {
+            return '';
+          }
+
+          const text = el.textContent?.trim() || '';
+
+          // Skip short or UI text
+          if (
+            text.length < 5 ||
+            text.includes('Open Emoji Keyboard') ||
+            text.includes('Download') ||
+            text.includes('MB') ||
+            text.includes('AM') ||
+            text.includes('PM')
+          ) {
+            return '';
+          }
+
+          return text;
+        });
+
+        if (content && !seenContent.has(content)) {
+          seenContent.add(content);
+
+          const isMe = await container.evaluate((el) => {
+            return el.closest('.msg-s-message-group--me') !== null;
+          });
+
+          messages.push({
+            id: `msg-${threadId}-${messages.length}`,
+            threadId,
+            sender: {
+              name: isMe ? 'You' : 'Other',
+              isMe,
+            },
+            content,
+            timestamp: new Date(),
+            isRead: true,
+          });
+        }
+      }
+    }
+
+    return messages;
+  }
+
+  /**
+   * Format thread messages as human-readable text (Style A)
+   */
+  formatThreadText(thread: Thread): string {
+    const lines: string[] = [];
+    const participantNames = thread.participants.map((p) => p.name).join(', ');
+
+    lines.push(`Conversations with ${participantNames}`);
+    lines.push('─'.repeat(60));
+
+    let lastDate = '';
+
+    for (const message of thread.messages) {
+      const date = message.timestamp.toLocaleDateString();
+      if (date !== lastDate) {
+        lines.push('');
+        lines.push(`─── ${date} ───`);
+        lastDate = date;
+      }
+
+      const time = message.timestamp.toLocaleTimeString([], {
+        hour: '2-digit',
+        minute: '2-digit',
+      });
+      const sender = message.sender.isMe ? 'You' : message.sender.name;
+
+      lines.push(`${time}  ${sender}: ${message.content}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format thread messages as JSON for LLM processing
+   */
+  formatThreadJson(thread: Thread): string {
+    return JSON.stringify(
+      {
+        threadId: thread.id,
+        participants: thread.participants,
+        messages: thread.messages.map((m) => ({
+          id: m.id,
+          sender: {
+            name: m.sender.name,
+            isMe: m.sender.isMe,
+          },
+          content: m.content,
+          timestamp: m.timestamp.toISOString(),
+        })),
+      },
+      null,
+      2
+    );
+  }
+
+  /**
+   * Parse a single message element
+   */
+  private async parseMessage(
+    element: ElementHandle<HTMLElement>,
+    threadId: string
+  ): Promise<Message | null> {
+    try {
+      // Extract message ID
+      const messageId = await element.evaluate((el) => {
+        const element = el as Element;
+        return (
+          element.getAttribute('data-urn') || element.id || `msg-${Date.now()}-${Math.random()}`
+        );
+      });
+
+      // Extract sender info - look for the sender name element
+      const senderInfo = await element
+        .$eval('.msg-s-message-group__name', (el) => ({
+          name: el.textContent?.trim() || '',
+          profileUrl: el.getAttribute('href') || undefined,
+        }))
+        .catch(() => ({ name: '', profileUrl: undefined }));
+
+      // Extract message content - look for the message body
+      let content = await element
+        .$eval('.msg-s-event-listitem__body', (el) => el.textContent?.trim() || '')
+        .catch(() => '');
+
+      // Fallback: try other content selectors
+      if (!content) {
+        content = await element
+          .$eval('.msg-s-message-group__message-body', (el) => el.textContent?.trim() || '')
+          .catch(() => '');
+      }
+
+      // Fallback: try any element that looks like message content
+      if (!content) {
+        const contentEl = await element.$('[class*="message-body"]');
+        if (contentEl) {
+          content = await contentEl.evaluate((el) => el.textContent?.trim() || '');
+        }
+      }
+
+      // Skip if no meaningful content
+      if (!content || content.length < 2) {
+        return null;
+      }
+
+      // Extract timestamp
+      let timestamp = new Date();
+      const datetimeAttr = await element
+        .$eval('time', (el) => el.getAttribute('datetime'))
+        .catch(() => null);
+
+      if (datetimeAttr) {
+        timestamp = new Date(datetimeAttr);
+      } else {
+        // Try to get timestamp from text content
+        const timeText = await element
+          .$eval('.msg-s-message-group__timestamp', (el) => el.textContent?.trim() || '')
+          .catch(() => '');
+
+        if (timeText) {
+          // Try to parse relative time
+          const now = new Date();
+          if (timeText.toLowerCase().includes('today')) {
+            timestamp = now;
+          } else if (timeText.toLowerCase().includes('yesterday')) {
+            timestamp = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+          }
+        }
+      }
+
+      // Check if message is from current user
+      const isMe = await element.evaluate((el) => {
+        const element = el as Element;
+        return (
+          element.classList.contains('msg-s-message-group--me') ||
+          element.classList.contains('sent') ||
+          element.closest('.msg-s-message-group--me') !== null
+        );
+      });
+
+      return {
+        id: messageId,
+        threadId,
+        sender: {
+          name: senderInfo.name || (isMe ? 'You' : 'Unknown'),
+          profileUrl: senderInfo.profileUrl,
+          isMe,
+        },
+        content,
+        timestamp,
+        isRead: true,
+      };
+    } catch (error) {
+      console.warn('Failed to parse message:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get thread participant information
+   */
+  private async getThreadParticipants(): Promise<Array<{ name: string; profileUrl?: string }>> {
+    try {
+      // Look for participant names in the thread header
+      const participants = await this.page.$$eval(
+        '.msg-entity-lockup__entity-title, [class*="participant-name"], [class*="thread-title"]',
+        (elements) =>
+          elements.map((el) => ({
+            name: el.textContent?.trim() || 'Unknown',
+            profileUrl: el.getAttribute('href') || undefined,
+          }))
+      );
+
+      if (participants.length > 0) {
+        return participants;
+      }
+    } catch {
+      // Fall through to default
+    }
+
+    return [{ name: 'Unknown', profileUrl: undefined }];
+  }
+}