linkedin-automation-cli 1.0.0

package/dist/linkedin/messages.js

@@ -0,0 +1,745 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedInMessages = void 0;
+const selector_engine_1 = require("./selector-engine");
+const selectors_1 = require("./selectors");
+class LinkedInMessages {
+    page;
+    selectorEngine;
+    constructor(page, _browser) {
+        this.page = page;
+        this.selectorEngine = new selector_engine_1.SelectorEngine(page);
+    }
+    /**
+     * Navigate to LinkedIn messaging page
+     */
+    async navigateToMessages() {
+        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 = {}) {
+        // Navigation is now handled by the caller - we're already on the messaging page
+        const limit = options.limit ?? 20;
+        const threads = [];
+        // 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 = [];
+        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.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
+     */
+    async parseThreadItem(item) {
+        try {
+            // Extract thread ID from data attribute or URL
+            const threadId = await item.evaluate((el) => {
+                const element = el;
+                // 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) => {
+                    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;
+            const datetimeAttr = await item.evaluate((el) => {
+                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 = {
+                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
+     */
+    async extractTextArrayFromElement(element, selectors) {
+        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
+     */
+    async extractTextFromElementSingle(element, selectors) {
+        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
+     */
+    async checkForUnreadIndicator(item) {
+        // 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) => {
+            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"
+     */
+    parseRelativeTimestamp(text) {
+        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) {
+        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_1.SELECTORS.messages.messageBubble.join(', '));
+        const messages = [];
+        for (let i = 0; i < Math.min(messageElements.length, limit); i++) {
+            const message = await this.parseMessage(messageElements[i], 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, limit = 50) {
+        // 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
+     */
+    async clickAndGetThreadId(emberId) {
+        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 = [];
+                for (const listItem of listItems) {
+                    const c = await listItem.$('.msg-conversation-card');
+                    if (c)
+                        conversationCards.push(c);
+                }
+                // Fallback to direct class match
+                if (conversationCards.length === 0) {
+                    conversationCards = (await this.page.$$('.msg-conversation-card'));
+                }
+                // 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) => 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];
+                }
+            }
+            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
+     */
+    async scrapeMessages(threadId, limit = 50) {
+        const messages = [];
+        // 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'));
+        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"]'));
+            const seenContent = new Set();
+            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) {
+        const lines = [];
+        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) {
+        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
+     */
+    async parseMessage(element, threadId) {
+        try {
+            // Extract message ID
+            const messageId = await element.evaluate((el) => {
+                const element = el;
+                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;
+                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
+     */
+    async getThreadParticipants() {
+        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 }];
+    }
+}
+exports.LinkedInMessages = LinkedInMessages;
+//# sourceMappingURL=messages.js.map