linkedin-agent-cli 0.1.0__py3-none-any.whl

linkedin_cli/actions/message.py

@@ -0,0 +1,153 @@
+# linkedin/actions/message.py
+import logging
+from typing import Dict, Any
+
+from playwright.sync_api import Error as PlaywrightError, Locator
+from linkedin_cli.browser.nav import goto_page, human_type, dump_page_html
+
+logger = logging.getLogger(__name__)
+
+LINKEDIN_MESSAGING_URL = "https://www.linkedin.com/messaging/thread/new/"
+
+# Selector fallback chains: semantic/ARIA first, then class-based.
+# LinkedIn A/B tests UI variants per account and renames classes often.
+# Each key maps to a list tried in order; first with a match wins.
+SELECTOR_CHAINS = {
+    # ── New thread: recipient search ──
+    "connections_input": [
+        'input[role="combobox"][placeholder*="name"]',
+        'input[class*="msg-connections"]',
+        'input[placeholder*="Type a name"]',
+        'input[type="text"][aria-owns]',
+    ],
+    "search_result_row": [
+        'ul[role="listbox"] li[role="option"]',
+        'div[class*="msg-connections-typeahead__search-result-row"]',
+        'li[class*="search-result"]',
+    ],
+    # ── Thread: compose area ──
+    "compose_input": [
+        'div[role="textbox"][aria-label*="Write a message"]',
+        'div[role="textbox"][aria-label*="message"i]',
+        'div[class*="msg-form__contenteditable"]',
+        'div[contenteditable="true"]',
+    ],
+    "compose_send": [
+        'button[type="submit"][class*="msg-form"]',
+        'button[class*="send-btn"]',
+        'button[class*="send-button"]',
+        'form button[type="submit"]',
+        'button[type="submit"]',
+    ],
+}
+
+
+def _find(page, key: str, timeout: int = 5000) -> Locator:
+    """Try each selector in the chain for *key*, return the first with matches.
+
+    Raises PlaywrightError if none match within *timeout* ms.
+    """
+    chain = SELECTOR_CHAINS[key]
+    for sel in chain:
+        loc = page.locator(sel)
+        try:
+            loc.first.wait_for(state="attached", timeout=timeout)
+            logger.debug("Selector hit for %s: %s", key, sel)
+            return loc
+        except (PlaywrightError, TimeoutError):
+            continue
+    tried = ", ".join(chain)
+    raise PlaywrightError(f"No selector matched for '{key}'. Tried: {tried}")
+
+
+# ── Public entry point ────────────────────────────────────────────
+
+
+def send_raw_message(session, profile: Dict[str, Any], message: str) -> bool:
+    """Send an arbitrary message to a profile. Returns True if sent."""
+    public_identifier = profile.get("public_identifier")
+
+    if _send_message(session, profile, message):
+        return True
+    dump_page_html(session, profile, category="message_direct")
+
+    if _send_message_via_api(session, profile, message):
+        return True
+
+    logger.error("All send methods failed for %s", public_identifier)
+    return False
+
+
+def _send_message(session, profile: Dict[str, Any], message: str) -> bool:
+    """Navigate to /messaging/thread/new/?recipient=<urn>, compose, send.
+
+    Uses the target URN (promoted to its own Lead column in crm.0005) to
+    skip the search-by-name step entirely. Post-migration 0007 the Lead
+    row no longer carries first_name/last_name, so name-based search is
+    not available anyway.
+    """
+    from linkedin_cli.api.messaging.utils import encode_urn
+
+    public_identifier = profile.get("public_identifier")
+    target_urn = profile.get("urn")
+    if not target_urn:
+        logger.error("Cannot send via direct thread: no URN for %s", public_identifier)
+        return False
+    try:
+        thread_url = f"{LINKEDIN_MESSAGING_URL}?recipient={encode_urn(target_urn)}"
+        goto_page(
+            session,
+            action=lambda: session.page.goto(thread_url),
+            expected_url_pattern="/messaging",
+            timeout=30_000,
+            error_message="Error opening messaging thread",
+        )
+        session.wait(1, 2)
+
+        human_type(
+            _find(session.page, "compose_input").first,
+            message,
+            min_delay=10,
+            max_delay=50,
+        )
+        _find(session.page, "compose_send").first.click(delay=200)
+        session.wait(0.5, 1)
+        logger.info("Message sent to %s (direct thread)", public_identifier)
+        return True
+    except (PlaywrightError, TimeoutError) as e:
+        logger.error("Failed to send message to %s (direct thread) → %s", public_identifier, e)
+        return False
+
+
+def _send_message_via_api(session, profile: Dict[str, Any], message: str) -> bool:
+    """Last-resort fallback: send via Voyager Messaging API.
+
+    Requires profile dict to contain 'urn' (target profile URN).
+    """
+    from linkedin_cli.api.client import PlaywrightLinkedinAPI
+    from linkedin_cli.api.messaging import send_message
+    from linkedin_cli.actions.conversations import find_conversation_urn, find_conversation_urn_via_navigation
+
+    public_identifier = profile.get("public_identifier")
+    target_urn = profile.get("urn")
+    if not target_urn:
+        logger.error("API send failed for %s → no URN in profile dict", public_identifier)
+        return False
+
+    mailbox_urn = session.self_profile["urn"]
+    api = PlaywrightLinkedinAPI(session=session)
+
+    conversation_urn = find_conversation_urn(api, target_urn, mailbox_urn)
+    if not conversation_urn:
+        conversation_urn = find_conversation_urn_via_navigation(session, target_urn)
+    if not conversation_urn:
+        logger.error("API send failed for %s → no conversation found", public_identifier)
+        return False
+
+    try:
+        send_message(api, conversation_urn, message, mailbox_urn)
+        logger.info("Message sent to %s (API fallback)", public_identifier)
+        return True
+    except Exception as e:
+        logger.error("API send failed for %s → %s", public_identifier, e)
+        return False

linkedin_cli/actions/profile.py

@@ -0,0 +1,22 @@
+# linkedin/actions/profile.py
+import logging
+
+from ..api.client import PlaywrightLinkedinAPI
+
+logger = logging.getLogger(__name__)
+
+
+def scrape_profile(session, profile: dict):
+    url = profile["url"]
+
+    session.ensure_browser()
+    session.wait()
+
+    api = PlaywrightLinkedinAPI(session=session)
+
+    logger.info("Enriching profile → %s", url)
+    profile, data = api.get_profile(profile_url=url)
+
+    logger.info("Profile enriched – %s", profile.get("public_identifier")) if profile else None
+
+    return profile, data

linkedin_cli/actions/search.py

@@ -0,0 +1,186 @@
+import json
+import logging
+from typing import Dict, Any
+from urllib.parse import urlparse, parse_qs, urlencode
+
+from linkedin_cli.browser.nav import goto_page, extract_in_urls
+
+# LinkedIn connection-degree filter codes for People search (`network` facet).
+NETWORK_CODES = {"first": "F", "second": "S", "third": "O"}
+
+logger = logging.getLogger(__name__)
+
+SELECTORS = {
+    "search_bar": "//input[contains(@placeholder, 'Search')]",
+    "profile_links": 'a[href*="/in/"]',
+}
+
+
+def _go_to_profile(session: "LinkedInSession", url: str, public_identifier: str):
+    if f"/in/{public_identifier}" in session.page.url:
+        return
+    logger.debug("Direct navigation → %s", public_identifier)
+    try:
+        goto_page(
+            session,
+            action=lambda: session.page.goto(url, wait_until="domcontentloaded"),
+            expected_url_pattern=f"/in/{public_identifier}",
+            error_message="Failed to navigate to the target profile"
+        )
+    except RuntimeError:
+        # Redirect to a different /in/ slug is tolerated; reconciling the
+        # lead's stored slug is the caller's job (this layer holds no DB).
+        if not _detect_profile_redirect(session, public_identifier):
+            raise
+
+
+def _detect_profile_redirect(session, old_public_id: str) -> str | None:
+    """Return the new public_id if LinkedIn redirected to a different /in/ slug."""
+    from urllib.parse import unquote
+    from linkedin_cli.url_utils import url_to_public_id
+
+    new_id = url_to_public_id(unquote(session.page.url))
+    if new_id and new_id != old_public_id:
+        logger.info("Profile redirect: %s → %s", old_public_id, new_id)
+        return new_id
+    return None
+
+
+def visit_profile(session: "LinkedInSession", profile: Dict[str, Any]):
+    public_identifier = profile.get("public_identifier")
+
+    # Ensure browser is alive before doing anything
+    session.ensure_browser()
+
+    already_there = f"/in/{public_identifier}" in session.page.url
+
+    if already_there:
+        return
+
+    url = profile.get("url")
+    _go_to_profile(session, url, public_identifier)
+
+    # Emit the /in/ profile URLs visible on the page; enrichment is caller-side.
+    return extract_in_urls(session.page)
+
+
+def _search_url(keyword: str, page: int = 1, network=None) -> str:
+    """Build a People-search results URL, optionally filtered by connection degree.
+
+    *network* is an optional list of degree codes — ``F`` (1st), ``S`` (2nd),
+    ``O`` (3rd+) — passed to LinkedIn's ``network`` facet as a JSON array.
+    """
+    params = {"keywords": keyword, "origin": "FACETED_SEARCH"}
+    if network:
+        params["network"] = json.dumps(list(network))
+    if page > 1:
+        params["page"] = page
+    return "https://www.linkedin.com/search/results/people/?" + urlencode(params)
+
+
+def _initiate_search(session: "LinkedInSession", keyword: str):
+    """Navigate directly to LinkedIn People search results for *keyword*."""
+    goto_page(
+        session,
+        action=lambda: session.page.goto(_search_url(keyword)),
+        expected_url_pattern="/search/results/people/",
+        error_message="Failed to reach People search results",
+    )
+
+
+def _paginate_to_next_page(session: "LinkedInSession", page_num: int):
+    page = session.page
+    current = urlparse(page.url)
+    params = parse_qs(current.query)
+    params["page"] = [str(page_num)]
+    new_url = current._replace(query=urlencode(params, doseq=True)).geturl()
+
+    logger.debug("Scanning search page %s", page_num)
+    goto_page(
+        session,
+        action=lambda: page.goto(new_url),
+        expected_url_pattern="/search/results/",
+        error_message="Pagination failed"
+    )
+
+
+def search_people(session: "LinkedInSession", keyword: str, page: int = 1, network=None) -> dict:
+    """Search LinkedIn People; return the result page as a structured envelope.
+
+    *network* optionally filters by connection degree (a list of `F`/`S`/`O`
+    codes). Results carry only ``{public_identifier, url}`` — no `urn`; a
+    follow-up `profile` scrape per url resolves the rest. Returns::
+
+        {"query": ..., "page": ..., "network": [...]|None,
+         "profiles": [{"public_identifier": ..., "url": ...}, ...]}
+    """
+    from linkedin_cli.url_utils import url_to_public_id
+
+    session.ensure_browser()
+    goto_page(
+        session,
+        action=lambda: session.page.goto(_search_url(keyword, page, network)),
+        expected_url_pattern="/search/results/people/",
+        error_message="Failed to reach People search results",
+    )
+
+    profiles, seen = [], set()
+    for url in extract_in_urls(session.page):
+        public_id = url_to_public_id(url)
+        if public_id and public_id not in seen:
+            seen.add(public_id)
+            profiles.append({"public_identifier": public_id, "url": url})
+
+    return {"query": keyword, "page": page,
+            "network": list(network) if network else None, "profiles": profiles}
+
+
+def _simulate_human_search(session: "LinkedInSession", profile: Dict[str, Any]) -> bool:
+    full_name = profile.get("full_name")
+    public_identifier = profile.get("public_identifier")
+
+    # Reconstruct full_name if it's missing
+    if not full_name:
+        first = profile.get("first_name", "").strip()
+        last = profile.get("last_name", "").strip()
+        if first or last:
+            full_name = f"{first} {last}".strip() if first and last else (first or last)
+        else:
+            logger.error(f"No name available for {public_identifier}")
+            logger.debug(profile)
+            return False
+
+    if not public_identifier:
+        logger.error(f"Missing public_identifier for '{full_name}'")
+        raise ValueError("public_identifier is required")
+
+    logger.info(f"Human search → '{full_name}' (target: {public_identifier})")
+
+    _initiate_search(session, full_name)
+
+    max_pages_to_scan = 1
+
+    for current_page in range(1, max_pages_to_scan + 1):
+        logger.info("Scanning search results page %s", current_page)
+
+        target_locator = None
+        for link in session.page.locator(SELECTORS["profile_links"]).all():
+            href = link.get_attribute("href") or ""
+            if f"/in/{public_identifier}" in href:
+                target_locator = link
+                break
+
+        if target_locator:
+            logger.info("Target found in results → clicking")
+            return False
+
+        if session.page.get_by_text("No results found", exact=False).count() > 0:
+            logger.info("No results found → stopping search")
+            break
+
+        if current_page < max_pages_to_scan:
+            _paginate_to_next_page(session, current_page + 1)
+            session.wait()
+
+    logger.info("Target %s not found → falling back to direct URL", public_identifier)
+    return False

linkedin_cli/actions/status.py

@@ -0,0 +1,112 @@
+# linkedin/actions/status.py
+import logging
+from typing import Dict, Any, Optional
+
+from linkedin_cli.actions.connect import SELECTORS as CONNECT_SELECTORS
+from linkedin_cli.actions.search import visit_profile
+from linkedin_cli.enums import ProfileState
+from linkedin_cli.browser.nav import find_top_card, dump_page_html
+
+logger = logging.getLogger(__name__)
+
+SELECTORS = {
+    "pending_button": '[aria-label*="Pending"]',
+    "invite_to_connect": CONNECT_SELECTORS["invite_to_connect"],
+    "more_button": CONNECT_SELECTORS["more_button"],
+    "connect_option": CONNECT_SELECTORS["connect_option"],
+}
+
+
+# ── API layer ──────────────────────────────────────────────────────
+
+def _fetch_degree(session, public_identifier: str, profile: Dict[str, Any]) -> Optional[int]:
+    """Return connection degree from API, trying two decorations.
+
+    1. Full profile scrape (FullProfileWithEntities) — mutates ``profile``
+       in place with the fresh fields and reads ``connection_degree``
+       from the response.
+    2. If that returns None, fall back to the lightweight
+       TopCardSupplementary endpoint.
+    """
+    from linkedin_cli.api.client import PlaywrightLinkedinAPI
+
+    api = PlaywrightLinkedinAPI(session=session)
+    fresh, _raw = api.get_profile(public_identifier=public_identifier)
+    if fresh:
+        profile.update(fresh)
+    degree = profile.get("connection_degree")
+
+    if degree is None:
+        degree = api.get_connection_degree(public_identifier)
+        logger.debug("TopCard degree lookup → %s", degree)
+
+    return degree
+
+
+# ── UI layer ───────────────────────────────────────────────────────
+
+def _inspect_ui(session, profile: Dict[str, Any]) -> ProfileState:
+    """Determine connection status from profile page buttons.
+
+    Returns PENDING, QUALIFIED (connect available), or CONNECTED
+    (no connect/pending buttons found).
+    """
+    visit_profile(session, profile)
+    session.wait()
+    top_card = find_top_card(session)
+
+    if top_card.locator(SELECTORS["pending_button"]).count() > 0:
+        logger.debug("UI → 'Pending' button detected")
+        return ProfileState.PENDING
+
+    if top_card.locator(SELECTORS["invite_to_connect"]).count() > 0:
+        logger.debug("UI → 'Connect' button detected")
+        return ProfileState.QUALIFIED
+
+    if _has_connect_in_more(session, top_card):
+        logger.debug("UI → 'Connect' in More menu")
+        return ProfileState.QUALIFIED
+
+    logger.debug("UI → no connect/pending indicators — dumping page")
+    dump_page_html(session, profile, category="status")
+    return ProfileState.QUALIFIED
+
+
+def _has_connect_in_more(session, top_card) -> bool:
+    more = top_card.locator(SELECTORS["more_button"])
+    if more.count() == 0:
+        return False
+    more.first.click()
+    session.wait()
+    # Dropdown may render as a portal outside top_card, so search page-wide
+    found = session.page.locator(SELECTORS["connect_option"]).count() > 0
+    if not found:
+        session.page.keyboard.press("Escape")
+    return found
+
+
+# ── Public entry point ─────────────────────────────────────────────
+
+def get_connection_status(
+        session: "LinkedInSession",
+        profile: Dict[str, Any],
+) -> ProfileState:
+    """Detect connection status via API with UI fallback.
+
+    Priority:
+      1. API degree (two decorations) — degree 1 = CONNECTED.
+      2. For degree 2/3 or None — UI inspection decides between
+         PENDING, QUALIFIED, and CONNECTED.
+    """
+    public_identifier = profile.get("public_identifier")
+    session.ensure_browser()
+    logger.debug("Checking connection status → %s", public_identifier)
+
+    degree = _fetch_degree(session, public_identifier, profile)
+
+    if degree == 1:
+        logger.debug("API degree 1 → CONNECTED")
+        return ProfileState.CONNECTED
+
+    # degree 2/3 or None — let the UI decide
+    return _inspect_ui(session, profile)

linkedin_cli/api/client.py

@@ -0,0 +1,182 @@
+# linkedin/api/client.py
+import json
+import logging
+from typing import Optional, Any
+from urllib.parse import urlencode
+
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from linkedin_cli.api.voyager import parse_linkedin_voyager_response, parse_connection_degree
+from linkedin_cli.url_utils import url_to_public_id
+from linkedin_cli.exceptions import (
+    AuthenticationError,
+    ProfileInaccessibleError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class _FetchResponse:
+    """Thin wrapper around the dict returned by page.evaluate(fetch(...))."""
+
+    __slots__ = ("status", "ok", "_text")
+
+    def __init__(self, raw: dict):
+        self.status: int = raw["status"]
+        self.ok: bool = raw["ok"]
+        self._text: str = raw["body"]
+
+    def json(self) -> Any:
+        return json.loads(self._text)
+
+    def text(self) -> str:
+        return self._text
+
+
+VOYAGER_REQUEST_TIMEOUT_MS = 30_000
+
+
+class PlaywrightLinkedinAPI:
+
+    def __init__(
+            self,
+            session: "LinkedInSession",
+            timeout_ms: int = VOYAGER_REQUEST_TIMEOUT_MS,
+    ):
+        self.session = session
+        self.page = session.page
+        self.context = session.context
+        self.timeout_ms = timeout_ms
+
+        # Extract cookies from the browser context to get JSESSIONID for csrf-token
+        cookies = self.context.cookies()
+        cookies_dict = {c['name']: c['value'] for c in cookies}
+        jsessionid = cookies_dict.get('JSESSIONID', '').strip('"')
+
+        # Only API-level headers; fetch() inside the page inherits
+        # browser-injected headers (x-li-track, sec-ch-*, user-agent, …).
+        self.headers = {
+            'accept': 'application/vnd.linkedin.normalized+json+2.1',
+            'csrf-token': jsessionid,
+            'x-li-lang': 'en_US',
+            'x-restli-protocol-version': '2.0.0',
+        }
+
+    # ── Transport ────────────────────────────────────────────────────
+
+    _FETCH_JS = """([method, url, headers, body, timeoutMs]) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const init = {method, headers, credentials: "include",
+                      signal: controller.signal};
+        if (body !== null) init.body = body;
+        return fetch(url, init).then(async r => {
+            clearTimeout(timer);
+            return {status: r.status, ok: r.ok, body: await r.text()};
+        });
+    }"""
+
+    def _fetch(self, method: str, url: str, headers: dict,
+               body: str | None = None) -> _FetchResponse:
+        """Run fetch() inside the browser page context.
+
+        Carries all browser-injected headers (x-li-track, cookies, sec-ch-*,
+        …) exactly like a real XHR. The JS-side AbortController enforces
+        the per-request deadline; if Chromium itself dies, page.evaluate
+        raises a Playwright error, the handler fails, and reconcile
+        re-creates the task on the next idle cycle.
+        """
+        raw = self.page.evaluate(
+            self._FETCH_JS,
+            [method, url, headers, body, self.timeout_ms],
+        )
+        return _FetchResponse(raw)
+
+    def get(self, url: str, *, headers: dict | None = None,
+            params: dict | None = None) -> _FetchResponse:
+        h = {**self.headers, **(headers or {})}
+        if params:
+            url = f"{url}?{urlencode(params)}"
+        return self._fetch("GET", url, h)
+
+    def post(self, url: str, *, headers: dict | None = None,
+             data: str | None = None) -> _FetchResponse:
+        h = {**self.headers, **(headers or {})}
+        return self._fetch("POST", url, h, body=data)
+
+    def _check_profile_response(self, res: _FetchResponse, public_identifier: str) -> None:
+        """Raise on auth/access errors; pass through on success."""
+        if res.status == 401:
+            logger.error("LinkedIn API → 401 Unauthorized (session expired or blocked)")
+            raise AuthenticationError("LinkedIn API returned 401 Unauthorized.")
+        if res.status in (403, 404):
+            logger.info("Profile inaccessible → private / deleted / restricted → %s (HTTP %d)",
+                        public_identifier, res.status)
+            raise ProfileInaccessibleError(f"{public_identifier} (HTTP {res.status})")
+        if not res.ok:
+            body_str = res.text()
+            logger.error("API request failed → %s | Status: %s", public_identifier, res.status)
+            raise IOError(f"LinkedIn API error {res.status}: {body_str[:500]}")
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=2, min=2, max=30),
+        retry=retry_if_exception_type(IOError),
+        reraise=True,
+    )
+    def get_profile(
+            self, public_identifier: Optional[str] = None, profile_url: Optional[str] = None
+    ) -> tuple[None, None] | tuple[dict, Any]:
+        if not public_identifier and profile_url:
+            public_identifier = url_to_public_id(profile_url)
+
+        if not public_identifier:  # None from url_to_public_id or missing arg
+            raise ValueError("Need public_identifier or profile_url")
+
+        params = {
+            'decorationId': 'com.linkedin.voyager.dash.deco.identity.profile.FullProfileWithEntities-91',
+            'memberIdentity': public_identifier,
+            'q': 'memberIdentity',
+        }
+
+        base_url = "https://www.linkedin.com/voyager/api"
+        uri = "/identity/dash/profiles"
+        full_url = base_url + uri
+
+        res = self.get(full_url, params=params)
+
+        self._check_profile_response(res, public_identifier)
+
+        data = res.json()
+        extracted_info = parse_linkedin_voyager_response(data, public_identifier=public_identifier)
+        return extracted_info, data
+
+    TOPCARD_DECORATION = (
+        "com.linkedin.voyager.dash.deco.identity.profile.TopCardSupplementary-120"
+    )
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=2, min=2, max=30),
+        retry=retry_if_exception_type(IOError),
+        reraise=True,
+    )
+    def get_connection_degree(self, public_identifier: str) -> int | None:
+        """Fetch connection degree via the TopCard decoration.
+
+        Uses a lightweight decoration that reliably includes
+        MemberRelationship entities even when FullProfileWithEntities
+        does not.  Returns 1/2/3 or None.
+        """
+        res = self.get(
+            "https://www.linkedin.com/voyager/api/identity/dash/profiles",
+            params={
+                "decorationId": self.TOPCARD_DECORATION,
+                "memberIdentity": public_identifier,
+                "q": "memberIdentity",
+            },
+        )
+
+        self._check_profile_response(res, public_identifier)
+
+        return parse_connection_degree(res.json())

linkedin_cli/api/messaging/__init__.py

@@ -0,0 +1,11 @@
+# linkedin/api/messaging/__init__.py
+"""Voyager Messaging API — send & retrieve messages."""
+from linkedin_cli.api.messaging.utils import (  # noqa: F401
+    encode_urn,
+    check_response,
+)
+from linkedin_cli.api.messaging.send import send_message  # noqa: F401
+from linkedin_cli.api.messaging.conversations import (  # noqa: F401
+    fetch_conversations,
+    fetch_messages,
+)