feat: linkedin messaging, get sidebar profiles

[aspectrr]

No description provided.

[greptile-apps]

Greptile Summary

This PR adds five new tools to the LinkedIn MCP server: get_sidebar_profiles (extracts profile recommendations from a person's page sidebar), get_inbox (lists recent messaging conversations), get_conversation (reads a specific thread by username or thread ID), search_conversations (keyword search across messages), and send_message (sends a message with an explicit confirm_send gate and optional profile URN shortcut). It also extracts and returns the profile_urn from a person's profile page, which can be fed back to send_message for a more reliable compose-URL construction path.

Key observations:

• The messaging infrastructure is well-structured, with fallback selectors, graceful error returns for each failure mode, and a dry-run mode via confirm_send=False.
• send_message contains a P1 logic issue: the post-send verification (_message_text_visible) searches document.body.innerText for the message text, but that text is already present in the compose box immediately after typing — the check passes regardless of whether the send actually succeeded.
• get_sidebar_profiles returns {url, sidebar_profiles: {...}} instead of the project-standard {url, sections: {name: text}} documented in CLAUDE.md.
• Test coverage is solid across both the extractor layer and the tool layer, including dry-run, profile URN, premium-redirect, and error-path cases.

Confidence Score: 4/5

Mostly safe to merge; one P1 issue means send_message can return sent: True even on a failed send, which should be fixed before production use.

The P1 issue in _message_text_visible means the sent field in the send_message response is not a reliable confirmation — callers cannot trust sent: True as proof of delivery. All other changes are well-implemented and tested.

linkedin_mcp_server/scraping/extractor.py — specifically the _message_text_visible method and its caller in send_message.

Important Files Changed

Filename	Overview
linkedin_mcp_server/scraping/extractor.py	Adds ~560 lines of new scraping logic for messaging inbox, conversation reading, search, sending, and sidebar profiles. Contains a P1 issue where _message_text_visible will always return True after typing, making the sent-confirmation unreliable.
linkedin_mcp_server/tools/messaging.py	New file registering four MCP tools (get_inbox, get_conversation, search_conversations, send_message). Error handling and progress reporting patterns are consistent with existing tools.
linkedin_mcp_server/tools/person.py	Adds get_sidebar_profiles tool; clean and consistent with existing patterns, though the return format deviates from the project-standard {url, sections: {}} envelope.
tests/test_scraping.py	Good test coverage for all new extractor methods including dry-run, unavailable, and profile URN paths.
tests/test_tools.py	Tool-layer tests for all five new tools including error paths; timeout registration checks updated correctly.

Sequence Diagram

sequenceDiagram
    participant C as MCP Client
    participant T as send_message tool
    participant E as LinkedInExtractor
    participant LI as LinkedIn (browser)

    C->>T: send_message(username, message, confirm_send, profile_urn?)
    T->>E: send_message(username, message, confirm_send, profile_urn)
    E->>LI: navigate /in/{username}/
    E->>LI: read profile display name
    alt profile_urn provided
        E-->>E: compose_url = /messaging/compose/?recipient={urn}
    else
        E->>LI: find messaging compose link href
    end
    E->>LI: navigate compose_url
    alt recipient_picker surface
        E->>LI: select recipient by display name
        alt selection fails
            E-->>T: recipient_resolution_failed
        end
    end
    E->>LI: verify compose page matches recipient
    alt confirm_send == False
        E-->>T: confirmation_required, sent: false
    end
    E->>LI: type message in compose box
    E->>LI: wait for send button enabled
    E->>LI: click send button
    E->>LI: _message_text_visible checks body.innerText
    Note over E,LI: Text already in compose box after typing - check may pass prematurely
    alt text found in body
        E-->>T: sent: true
    else
        E-->>T: send_unavailable, sent: false
    end
    T-->>C: result dict

Loading

Comments Outside Diff (1)

1. linkedin_mcp_server/scraping/extractor.py, line 1064-1071 (link)

   _message_text_visible always returns True after typing — unreliable send confirmation

   _message_text_visible checks document.body.innerText for the message text. However, at the point this check is called, the message was already typed into the compose box (lines 1022–1023) and is therefore already present in document.body.innerText. The wait_for_function will satisfy on the very first poll because the text is still in the compose box, regardless of whether the send button click actually caused a successful delivery.

   If the send fails (network error, LinkedIn validation error, etc.), LinkedIn typically retains the message text in the compose box so the user can retry. In that case _message_text_visible returns True, sent=True is emitted, and callers have no reliable signal that the message was not delivered.

   A more reliable approach is to verify the compose box is cleared after the click rather than checking that the text exists anywhere on the page:

   async def _compose_box_cleared(self, *, timeout: int = 5000) -> bool:
       try:
           await self._page.wait_for_function(
               """(selector) => {
                   const el = document.querySelector(selector);
                   return el ? (el.innerText || el.textContent || '').trim() === '' : true;
               }""",
               arg=_MESSAGING_COMPOSE_SELECTOR,
               timeout=timeout,
           )
           return True
       except PlaywrightTimeoutError:
           return False

Prompt To Fix All With AI

This is a comment left during a code review.
Path: linkedin_mcp_server/scraping/extractor.py
Line: 1064-1071

Comment:
**`_message_text_visible` always returns `True` after typing — unreliable send confirmation**

`_message_text_visible` checks `document.body.innerText` for the message text. However, at the point this check is called, the message was already typed into the compose box (lines 1022–1023) and is therefore *already present* in `document.body.innerText`. The `wait_for_function` will satisfy on the very first poll because the text is still in the compose box, regardless of whether the send button click actually caused a successful delivery.

If the send fails (network error, LinkedIn validation error, etc.), LinkedIn typically retains the message text in the compose box so the user can retry. In that case `_message_text_visible` returns `True`, `sent=True` is emitted, and callers have no reliable signal that the message was not delivered.

A more reliable approach is to verify the compose box is **cleared** after the click rather than checking that the text exists anywhere on the page:

```python
async def _compose_box_cleared(self, *, timeout: int = 5000) -> bool:
    try:
        await self._page.wait_for_function(
            """(selector) => {
                const el = document.querySelector(selector);
                return el ? (el.innerText || el.textContent || '').trim() === '' : true;
            }""",
            arg=_MESSAGING_COMPOSE_SELECTOR,
            timeout=timeout,
        )
        return True
    except PlaywrightTimeoutError:
        return False
```

How can I resolve this? If you propose a fix, please make it concise.

---

This is a comment left during a code review.
Path: linkedin_mcp_server/scraping/extractor.py
Line: 256-268

Comment:
**`get_sidebar_profiles` return format deviates from project standard**

Per the project's style guide, all scraping tools must return `{url, sections: {name: raw_text}}`. `get_sidebar_profiles` returns `{url, sidebar_profiles: {...}}` instead, bypassing the `sections` envelope.

Consider wrapping the result for consistency:

```python
return {
    "url": url,
    "sections": {"sidebar_profiles": sidebar_profiles},
}
```

Or explicitly document the intentional deviation in the docstring and CLAUDE.md.

**Context Used:** CLAUDE.md ([source](https://app.greptile.com/review/custom-context?memory=e3726abd-137d-439d-b03c-d01e1ba139d4))

How can I resolve this? If you propose a fix, please make it concise.

_{Reviews (4): Last reviewed commit: "fix: Add baseline comment for messaging ..." | Re-trigger Greptile}

[Copilot]

Pull request overview

Adds new LinkedIn capabilities to the MCP server: scraping sidebar “recommended profiles” from a person page, and a new messaging tool suite (inbox/conversations/search/send), backed by new extractor functionality and tests.

Changes:

• Add get_sidebar_profiles tool and extractor support for sidebar recommendation sections.
• Introduce messaging tools (get_inbox, get_conversation, search_conversations, send_message) and register them on the server.
• Extend scraping/extractor with profile URN extraction and messaging page automation; update manifest/tests/docs accordingly.

Reviewed changes

Copilot reviewed 9 out of 9 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
tests/test_tools.py	Adds tool-level tests for sidebar + messaging tools and updates timeout coverage list.
tests/test_scraping.py	Adds extractor-level tests for sidebar profiles, profile URN extraction, and messaging flows.
manifest.json	Publishes new tool names/descriptions in the MCP bundle manifest.
linkedin_mcp_server/tools/person.py	Registers the new get_sidebar_profiles MCP tool.
linkedin_mcp_server/tools/messaging.py	New module registering inbox/conversation/search/send messaging tools.
linkedin_mcp_server/tools/init.py	Updates tool module documentation to mention messaging tools.
linkedin_mcp_server/server.py	Registers messaging tools on server startup.
linkedin_mcp_server/scraping/extractor.py	Implements sidebar scraping, profile URN extraction, and messaging automation helpers.
README.md	Adds get_sidebar_profiles to the tool status table.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

scrape_person now conditionally adds a profile_urn field to the returned dict (see the new result["profile_urn"] assignment). The method’s docstring still documents only {url, sections} as the return shape; please update it so callers/tests/documentation reflect the optional profile_urn key.

[Copilot]

LinkedInExtractor now has _conversation_thread_cache, but get_ready_extractor() constructs a new LinkedInExtractor(browser.page) for each tool call, so this cache will be empty on every call in normal usage. Consider removing it or moving the cache to a longer-lived place (e.g., session/browser state) if cross-call caching is intended.

Suggested change

	self._conversation_thread_cache: dict[str, str] = {}
	# Share the conversation thread cache across extractor instances that
	# operate on the same Page, so cached data persists between tool calls.
	existing_cache = getattr(page, "_conversation_thread_cache", None)
	if existing_cache is None:
	existing_cache = {}
	setattr(page, "_conversation_thread_cache", existing_cache)
	self._conversation_thread_cache = existing_cache

[Copilot]

get_sidebar_profiles does not handle AuthenticationError the same way the other person tools do. Since LinkedInExtractor navigation can raise AuthenticationError, this tool should catch it and delegate to handle_auth_error(e, ctx) (mirroring get_person_profile/search_people/connect_with_person) so callers get the standard re-login flow instead of a generic ToolError.

Suggested change

	except AuthenticationError as e:
	try:
	await handle_auth_error(e, ctx)
	except Exception as relogin_exc:
	raise_tool_error(relogin_exc, "get_sidebar_profiles")

[Copilot]

Messaging tools currently don’t handle AuthenticationError/re-login the way the existing person/company/job tools do. Because extractor navigation can raise AuthenticationError after get_ready_extractor returns, these tools should add an except AuthenticationError as e: await handle_auth_error(e, ctx) branch (and import AuthenticationError + handle_auth_error) so stale sessions trigger the standard re-auth flow.

[Copilot]

New messaging selector constants _MESSAGING_THREAD_LINK_SELECTOR, _MESSAGING_RESULT_ITEM_SELECTOR, and _MESSAGING_SEND_SELECTOR are currently unused in this module. Either remove them to avoid dead code, or switch the relevant querySelector/querySelectorAll calls to use them so there’s a single source of truth for these selectors.

[Copilot]

_click_first’s docstring says it clicks the first visible locator, but the implementation always targets .first without ensuring visibility. Either adjust the implementation to find a visible element (or wait for visible before clicking), or update the docstring to reflect the actual behavior to avoid misleading future changes.

[Copilot]

The README tool-status table is meant to enumerate the available MCP tools, but it now omits the newly added messaging tools (get_inbox, get_conversation, search_conversations, send_message). Please add rows for these tools (and brief descriptions) so documentation matches the server/manifest capabilities.