linkedin-agent-cli 0.1.0__tar.gz

linkedin_agent_cli-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+uv.lock

linkedin_agent_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eracle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linkedin_agent_cli-0.1.0/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: linkedin-agent-cli
+Version: 0.1.0
+Summary: Django-free library and CLI for LinkedIn platform mechanics over a bound browser session (Voyager API + Playwright).
+Project-URL: Homepage, https://github.com/eracle/linkedin-cli
+Project-URL: Repository, https://github.com/eracle/linkedin-cli
+Project-URL: Issues, https://github.com/eracle/linkedin-cli/issues
+Author-email: eracle <eracle@posteo.eu>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-tools,ai-agent,browser-automation,cli,lead-generation,linkedin,linkedin-api,linkedin-automation,linkedin-scraper,llm,outreach,playwright,voyager,web-scraping
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: playwright-stealth
+Requires-Dist: playwright>=1.59
+Requires-Dist: tenacity<10,>=8
+Requires-Dist: termcolor
+Description-Content-Type: text/markdown
+
+# linkedin-cli
+
+**Drive LinkedIn from the command line or any program** — search people, scrape
+profiles, check connection status, send connection requests, and read or send
+messages. One small, dependency-light Python tool that talks to LinkedIn's
+private **Voyager API** through a **real, logged-in browser** (Playwright), so
+it behaves like a human session instead of a cookie-only scraper.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Playwright](https://img.shields.io/badge/browser-Playwright-2EAD33)
+
+> No SaaS, no API key, no database. Your browser, your LinkedIn account, your machine.
+
+---
+
+## ✨ Why linkedin-cli
+
+- **Real browser session, not raw cookies.** A persistent Chromium window is
+  launched once and shared; requests ride your live, authenticated session —
+  far more resilient than header/cookie replay.
+- **Structured JSON out of every command.** Pipe it into `jq`, a script, or an
+  LLM agent. Human-readable summaries by default; `--json` for the full record.
+- **Robust login.** Authentication is a small **page-state machine** that
+  understands LinkedIn's login, authwall, and security-checkpoint redirects —
+  not a brittle one-shot form fill.
+- **Language-agnostic.** Anything that can run a subprocess and parse JSON can
+  drive LinkedIn — Python, Node, Go, shell, or an AI agent. No SDK lock-in.
+- **Tiny surface.** Eight verbs, four dependencies, zero web framework. It knows
+  about *a LinkedIn page and a browser* — nothing else.
+
+## 📦 Install
+
+```bash
+pip install linkedin-agent-cli
+python -m playwright install chromium
+```
+
+This installs the `linkedin-cli` command (equivalent to `python -m linkedin_cli.cli`).
+The PyPI package is `linkedin-agent-cli`; the import name is `linkedin_cli`. For the
+latest unreleased code, install from git:
+`pip install "linkedin-agent-cli @ git+https://github.com/eracle/linkedin-cli.git@main"`.
+
+## 🚀 Quickstart
+
+linkedin-cli uses a **bind + connect** model: one long-lived process owns the
+browser; every command is a short client that connects to it.
+
+```bash
+# 1. Open + bind a session once (this process owns the browser window).
+linkedin-cli session open --session work
+
+# 2. From any other shell, drive it. Set the session once via env:
+export LINKEDIN_CLI_SESSION=work
+export LINKEDIN_USERNAME="you@example.com"
+export LINKEDIN_PASSWORD="••••••••"
+
+linkedin-cli login                                    # authenticate the session
+linkedin-cli search "head of growth" --network first  # discover → handles
+linkedin-cli profile alice-smith                      # scrape a profile
+linkedin-cli profile alice-smith --json > alice.json  # save the full record
+linkedin-cli status  alice-smith                      # Connected / Pending / Qualified
+linkedin-cli connect alice-smith                      # send a connection request
+linkedin-cli message alice-smith --text "Hi Alice 👋"
+linkedin-cli thread  alice-smith                      # read the conversation
+
+linkedin-cli session close
+```
+
+Hit a security checkpoint? `playwright-cli attach work` opens the *same* browser
+so you can clear it by hand, then carry on.
+
+## 🧰 Commands
+
+`--session <name>` (or `$LINKEDIN_CLI_SESSION`) and `--json` apply to every command.
+
+| Command | What it does | `--json` result |
+|---|---|---|
+| `login` | Authenticate the session (creds from env), clear checkpoints, discover your own profile | `{account, self}` |
+| `whoami` | Who is this session logged in as (no login flow) | `{self}` |
+| `search <kw> [--network first/second/third] [--page N]` | People search → matching profile handles | `{query, page, network, profiles[]}` |
+| `profile <id>` | Scrape a profile (positions, education, location, …); `--raw` adds the raw Voyager blob | full `LinkedInProfile` |
+| `status <id>` | Connection state | `{public_identifier, state}` |
+| `connect <id>` | Send a connection request (no note) | `{public_identifier, state}` |
+| `message <id> --text …` | Send a direct message | `{public_identifier, sent}` |
+| `thread <id>` | Read a conversation's messages | `{public_identifier, messages[]}` |
+
+An `<id>` is a public handle (`alice-smith`) or a full profile URL. Commands that
+need the internal member `urn` (`message`/`thread`/`status`) resolve it for you —
+every command is independent and takes only a handle.
+
+## 🤖 Built for AI agents (and any language)
+
+linkedin-cli is designed to be driven by an LLM as a **deterministic tool**. The
+properties that make it agent-friendly:
+
+- **Stable, typed JSON contract** — every verb returns one documented dict;
+  maps directly onto a function-calling / tool-use schema.
+- **id-only, stateless commands** — a public handle is the only argument an agent
+  threads between steps; no session tokens, urns, or cursors to carry.
+- **Predictable error taxonomy** — failures surface as `error: <type>: <message>`
+  on stderr with a non-zero exit, so an agent can branch on `type`
+  (`checkpoint_challenge`, `authentication`, `connection_limit`, …).
+- **No hidden state or side effects** — stdout is result-only; logs go to stderr.
+- **Self-describing** — see [`llms.txt`](llms.txt) for a compact spec an LLM can
+  load directly, and `linkedin-cli <verb> --help` for per-verb usage.
+
+Because every command emits JSON on stdout, you can drive LinkedIn from anything —
+Python, Node, Go, shell, or an agent loop — no SDK and no Python import required:
+
+```python
+import subprocess, json
+
+def li(*args):
+    out = subprocess.run(["linkedin-cli", *args, "--json"],
+                         capture_output=True, text=True, check=True)
+    return json.loads(out.stdout)
+
+for hit in li("search", "head of growth", "--network", "first")["profiles"]:
+    handle = hit["public_identifier"]
+    if li("status", handle)["state"] == "Qualified":
+        li("message", handle, "--text", "Hi — loved your recent post!")
+```
+
+The discovery → outreach loop an agent runs: **`search` → `profile` / `status` →
+`message` / `thread`.**
+
+## 🧠 How it works
+
+- **bind + connect** — `linkedin-cli session open` launches a persistent Chromium
+  with `Browser.bind()` (Playwright ≥ 1.59) and registers a local `ws://`
+  endpoint under the session name. Each command `chromium.connect()`s to that same
+  browser and drives a *real* page. Auth, cookies, and fingerprint live in the
+  owner's on-disk profile; the CLI keeps only a name→endpoint registry — **no
+  database**. One session = one LinkedIn account.
+- **Voyager API** — reads (`profile`, `thread`, `status`) call LinkedIn's private
+  Voyager endpoints from inside the authenticated page (`fetch`), then parse the
+  JSON — fast and structured, no DOM scraping where an API exists.
+- **Page-state auth machine** — `classify_page()` judges the live page by URL
+  *path* only (so a `/login?...redirect=/feed/` URL never reads as the feed), and
+  each transition asserts its pre/post state, raising on an illegal jump. Login,
+  authwall, and checkpoint flows are modeled explicitly.
+
+## 📤 Output contract
+
+- Every command produces one result **dict** — that dict is both the `--json`
+  payload and the source the human summary is rendered from, so the two never drift.
+- **Human-readable by default; `--json` for the full dict.**
+- **No `--out` flag** — print to stdout, redirect to save (`… --json > out.json`).
+- **stdout is result-only; logs and errors go to stderr** as
+  `error: <type>: <message>` with a non-zero exit. Error types are stable:
+  `checkpoint_challenge`, `authentication`, `profile_inaccessible`,
+  `skip_profile`, `connection_limit`.
+
+## ⚠️ Responsible use
+
+This tool automates **your own** LinkedIn account from **your own** machine.
+Automating LinkedIn may conflict with its Terms of Service, and aggressive use
+can get an account restricted. Respect rate limits, only contact people for
+legitimate reasons, follow applicable laws (GDPR/CAN-SPAM), and use it at your
+own risk. You are responsible for how you use it.
+
+## 📄 License
+
+[MIT](LICENSE) © eracle
+
+---
+
+linkedin-cli was extracted from [**OpenOutreach**](https://github.com/eracle/OpenOutreach),
+an open-source AI outreach tool, where it powers the LinkedIn discovery and
+interaction layer. It is fully standalone and reusable on its own.

linkedin_agent_cli-0.1.0/README.md

@@ -0,0 +1,171 @@
+# linkedin-cli
+
+**Drive LinkedIn from the command line or any program** — search people, scrape
+profiles, check connection status, send connection requests, and read or send
+messages. One small, dependency-light Python tool that talks to LinkedIn's
+private **Voyager API** through a **real, logged-in browser** (Playwright), so
+it behaves like a human session instead of a cookie-only scraper.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Playwright](https://img.shields.io/badge/browser-Playwright-2EAD33)
+
+> No SaaS, no API key, no database. Your browser, your LinkedIn account, your machine.
+
+---
+
+## ✨ Why linkedin-cli
+
+- **Real browser session, not raw cookies.** A persistent Chromium window is
+  launched once and shared; requests ride your live, authenticated session —
+  far more resilient than header/cookie replay.
+- **Structured JSON out of every command.** Pipe it into `jq`, a script, or an
+  LLM agent. Human-readable summaries by default; `--json` for the full record.
+- **Robust login.** Authentication is a small **page-state machine** that
+  understands LinkedIn's login, authwall, and security-checkpoint redirects —
+  not a brittle one-shot form fill.
+- **Language-agnostic.** Anything that can run a subprocess and parse JSON can
+  drive LinkedIn — Python, Node, Go, shell, or an AI agent. No SDK lock-in.
+- **Tiny surface.** Eight verbs, four dependencies, zero web framework. It knows
+  about *a LinkedIn page and a browser* — nothing else.
+
+## 📦 Install
+
+```bash
+pip install linkedin-agent-cli
+python -m playwright install chromium
+```
+
+This installs the `linkedin-cli` command (equivalent to `python -m linkedin_cli.cli`).
+The PyPI package is `linkedin-agent-cli`; the import name is `linkedin_cli`. For the
+latest unreleased code, install from git:
+`pip install "linkedin-agent-cli @ git+https://github.com/eracle/linkedin-cli.git@main"`.
+
+## 🚀 Quickstart
+
+linkedin-cli uses a **bind + connect** model: one long-lived process owns the
+browser; every command is a short client that connects to it.
+
+```bash
+# 1. Open + bind a session once (this process owns the browser window).
+linkedin-cli session open --session work
+
+# 2. From any other shell, drive it. Set the session once via env:
+export LINKEDIN_CLI_SESSION=work
+export LINKEDIN_USERNAME="you@example.com"
+export LINKEDIN_PASSWORD="••••••••"
+
+linkedin-cli login                                    # authenticate the session
+linkedin-cli search "head of growth" --network first  # discover → handles
+linkedin-cli profile alice-smith                      # scrape a profile
+linkedin-cli profile alice-smith --json > alice.json  # save the full record
+linkedin-cli status  alice-smith                      # Connected / Pending / Qualified
+linkedin-cli connect alice-smith                      # send a connection request
+linkedin-cli message alice-smith --text "Hi Alice 👋"
+linkedin-cli thread  alice-smith                      # read the conversation
+
+linkedin-cli session close
+```
+
+Hit a security checkpoint? `playwright-cli attach work` opens the *same* browser
+so you can clear it by hand, then carry on.
+
+## 🧰 Commands
+
+`--session <name>` (or `$LINKEDIN_CLI_SESSION`) and `--json` apply to every command.
+
+| Command | What it does | `--json` result |
+|---|---|---|
+| `login` | Authenticate the session (creds from env), clear checkpoints, discover your own profile | `{account, self}` |
+| `whoami` | Who is this session logged in as (no login flow) | `{self}` |
+| `search <kw> [--network first/second/third] [--page N]` | People search → matching profile handles | `{query, page, network, profiles[]}` |
+| `profile <id>` | Scrape a profile (positions, education, location, …); `--raw` adds the raw Voyager blob | full `LinkedInProfile` |
+| `status <id>` | Connection state | `{public_identifier, state}` |
+| `connect <id>` | Send a connection request (no note) | `{public_identifier, state}` |
+| `message <id> --text …` | Send a direct message | `{public_identifier, sent}` |
+| `thread <id>` | Read a conversation's messages | `{public_identifier, messages[]}` |
+
+An `<id>` is a public handle (`alice-smith`) or a full profile URL. Commands that
+need the internal member `urn` (`message`/`thread`/`status`) resolve it for you —
+every command is independent and takes only a handle.
+
+## 🤖 Built for AI agents (and any language)
+
+linkedin-cli is designed to be driven by an LLM as a **deterministic tool**. The
+properties that make it agent-friendly:
+
+- **Stable, typed JSON contract** — every verb returns one documented dict;
+  maps directly onto a function-calling / tool-use schema.
+- **id-only, stateless commands** — a public handle is the only argument an agent
+  threads between steps; no session tokens, urns, or cursors to carry.
+- **Predictable error taxonomy** — failures surface as `error: <type>: <message>`
+  on stderr with a non-zero exit, so an agent can branch on `type`
+  (`checkpoint_challenge`, `authentication`, `connection_limit`, …).
+- **No hidden state or side effects** — stdout is result-only; logs go to stderr.
+- **Self-describing** — see [`llms.txt`](llms.txt) for a compact spec an LLM can
+  load directly, and `linkedin-cli <verb> --help` for per-verb usage.
+
+Because every command emits JSON on stdout, you can drive LinkedIn from anything —
+Python, Node, Go, shell, or an agent loop — no SDK and no Python import required:
+
+```python
+import subprocess, json
+
+def li(*args):
+    out = subprocess.run(["linkedin-cli", *args, "--json"],
+                         capture_output=True, text=True, check=True)
+    return json.loads(out.stdout)
+
+for hit in li("search", "head of growth", "--network", "first")["profiles"]:
+    handle = hit["public_identifier"]
+    if li("status", handle)["state"] == "Qualified":
+        li("message", handle, "--text", "Hi — loved your recent post!")
+```
+
+The discovery → outreach loop an agent runs: **`search` → `profile` / `status` →
+`message` / `thread`.**
+
+## 🧠 How it works
+
+- **bind + connect** — `linkedin-cli session open` launches a persistent Chromium
+  with `Browser.bind()` (Playwright ≥ 1.59) and registers a local `ws://`
+  endpoint under the session name. Each command `chromium.connect()`s to that same
+  browser and drives a *real* page. Auth, cookies, and fingerprint live in the
+  owner's on-disk profile; the CLI keeps only a name→endpoint registry — **no
+  database**. One session = one LinkedIn account.
+- **Voyager API** — reads (`profile`, `thread`, `status`) call LinkedIn's private
+  Voyager endpoints from inside the authenticated page (`fetch`), then parse the
+  JSON — fast and structured, no DOM scraping where an API exists.
+- **Page-state auth machine** — `classify_page()` judges the live page by URL
+  *path* only (so a `/login?...redirect=/feed/` URL never reads as the feed), and
+  each transition asserts its pre/post state, raising on an illegal jump. Login,
+  authwall, and checkpoint flows are modeled explicitly.
+
+## 📤 Output contract
+
+- Every command produces one result **dict** — that dict is both the `--json`
+  payload and the source the human summary is rendered from, so the two never drift.
+- **Human-readable by default; `--json` for the full dict.**
+- **No `--out` flag** — print to stdout, redirect to save (`… --json > out.json`).
+- **stdout is result-only; logs and errors go to stderr** as
+  `error: <type>: <message>` with a non-zero exit. Error types are stable:
+  `checkpoint_challenge`, `authentication`, `profile_inaccessible`,
+  `skip_profile`, `connection_limit`.
+
+## ⚠️ Responsible use
+
+This tool automates **your own** LinkedIn account from **your own** machine.
+Automating LinkedIn may conflict with its Terms of Service, and aggressive use
+can get an account restricted. Respect rate limits, only contact people for
+legitimate reasons, follow applicable laws (GDPR/CAN-SPAM), and use it at your
+own risk. You are responsible for how you use it.
+
+## 📄 License
+
+[MIT](LICENSE) © eracle
+
+---
+
+linkedin-cli was extracted from [**OpenOutreach**](https://github.com/eracle/OpenOutreach),
+an open-source AI outreach tool, where it powers the LinkedIn discovery and
+interaction layer. It is fully standalone and reusable on its own.

linkedin_agent_cli-0.1.0/llms.txt

@@ -0,0 +1,54 @@
+# linkedin-cli
+
+> A command-line tool and Python library that drives LinkedIn through a real,
+> logged-in browser (Playwright) and LinkedIn's private Voyager API. It is meant
+> to be used by LLM agents as a deterministic tool: every command takes a public
+> profile handle and emits a single JSON object on stdout. Logs and errors go to
+> stderr. There is no API key, no SaaS, and no database — it drives the user's own
+> LinkedIn account on the user's own machine.
+
+## How to use it
+
+A session owner launches and binds one persistent browser; each command connects
+to it. Select the session with `--session <name>` or `$LINKEDIN_CLI_SESSION`.
+Add `--json` to any verb for the full result dict (the default prints a short
+human summary). Credentials come from `$LINKEDIN_USERNAME` / `$LINKEDIN_PASSWORD`.
+
+```
+linkedin-cli session open --session work   # start once; owns the browser, blocks
+linkedin-cli login                         # authenticate the bound session
+linkedin-cli session close                 # stop the session
+```
+
+An `<id>` argument is a public handle (e.g. `alice-smith`) or a profile URL.
+Commands are independent and stateless; the only thing an agent threads between
+steps is the handle.
+
+## Commands and JSON results
+
+- `login` → `{ "account": str, "self": { "public_identifier", "urn", "full_name" } }`
+- `whoami` → `{ "self": { "public_identifier", "urn", "full_name" } }`
+- `search <keywords> [--network first|second|third] [--page N]` →
+  `{ "query", "page", "network": [..], "profiles": [ { "public_identifier", "url" } ] }`
+- `profile <id> [--raw]` → full LinkedIn profile:
+  `{ "url", "urn", "public_identifier", "full_name", "headline", "summary",
+     "location_name", "positions": [..], "educations": [..], "connection_degree" }`
+- `status <id>` → `{ "public_identifier", "state": "Connected"|"Pending"|"Qualified" }`
+- `connect <id>` → `{ "public_identifier", "state": "Pending"|"Qualified" }` (no note)
+- `message <id> --text <msg>` → `{ "public_identifier", "sent": bool }`
+- `thread <id>` → `{ "public_identifier", "messages": [ { "sender", "text", "timestamp" } ] }`
+
+## Errors
+
+On failure: non-zero exit and a line on stderr `error: <type>: <message>`.
+Stable `type` values to branch on: `checkpoint_challenge`, `authentication`,
+`profile_inaccessible`, `skip_profile`, `connection_limit`.
+
+## Typical agent loop
+
+search → for each handle: profile and/or status → message and/or thread.
+
+## More
+
+- README: https://github.com/eracle/linkedin-cli/blob/main/README.md
+- Per-verb help: `linkedin-cli <verb> --help`

linkedin_agent_cli-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "linkedin-agent-cli"
+version = "0.1.0"
+description = "Django-free library and CLI for LinkedIn platform mechanics over a bound browser session (Voyager API + Playwright)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "eracle", email = "eracle@posteo.eu" }]
+keywords = [
+    "linkedin", "linkedin-api", "linkedin-automation", "linkedin-scraper",
+    "voyager", "playwright", "browser-automation", "web-scraping", "cli",
+    "outreach", "lead-generation", "ai-agent", "llm", "agent-tools",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: Browsers",
+    "Topic :: Office/Business",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "playwright>=1.59",
+    "playwright-stealth",
+    "tenacity>=8,<10",
+    "termcolor",
+]
+
+[project.urls]
+Homepage = "https://github.com/eracle/linkedin-cli"
+Repository = "https://github.com/eracle/linkedin-cli"
+Issues = "https://github.com/eracle/linkedin-cli/issues"
+
+[project.scripts]
+linkedin-cli = "linkedin_cli.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/linkedin_cli"]

linkedin_agent_cli-0.1.0/src/linkedin_cli/__init__.py

@@ -0,0 +1,9 @@
+"""linkedin_cli — standalone, Django-free LinkedIn interaction library.
+
+Owns the LinkedIn *platform* mechanics — navigation, login, the Voyager API
+client, profile/conversation scraping, and the connect/message/status/thread
+verbs. It holds no database and no campaign/CRM context: every verb runs
+against a browser session supplied by the caller (see ``session.LinkedInSession``).
+"""
+
+__version__ = "0.1.0"

linkedin_agent_cli-0.1.0/src/linkedin_cli/actions/connect.py

@@ -0,0 +1,118 @@
+# linkedin/actions/connect.py
+import logging
+from typing import Dict, Any
+
+from linkedin_cli.enums import ProfileState
+from linkedin_cli.exceptions import SkipProfile, ReachedConnectionLimit
+from linkedin_cli.browser.nav import find_top_card, dump_page_html
+
+logger = logging.getLogger(__name__)
+
+SELECTORS = {
+    "weekly_limit": 'div[class*="ip-fuse-limit-alert__warning"]',
+    "invite_to_connect": (
+        '[aria-label*="Invite"][aria-label*="to connect"]:visible, '
+        'a:has(span:text-is("Connect")):visible, '
+        'button:has(span:text-is("Connect")):visible'
+    ),
+    "error_toast": 'div[data-test-artdeco-toast-item-type="error"]',
+    "more_button": (
+        'button[aria-label="More"]:visible, '
+        'button[id*="overflow"]:visible, '
+        'button[aria-label*="More actions"]:visible, '
+        'button:has(span:text-is("More")):visible'
+    ),
+    "connect_option": (
+        'div[role="button"][aria-label^="Invite"][aria-label*=" to connect"], '
+        'div[role="button"]:text-is("Connect"), '
+        '[role="menuitem"][aria-label*="Connect"], '
+        '[role="menuitem"]:has-text("Connect"), '
+        'li:text-is("Connect"), '
+        'span[role="button"]:text-is("Connect")'
+    ),
+    "send_now": 'button:has-text("Send now"), button[aria-label*="Send without"], button[aria-label*="Send invitation"]',
+}
+
+
+def send_connection_request(
+        session: "LinkedInSession",
+        profile: Dict[str, Any],
+) -> ProfileState:
+    """
+    Sends a LinkedIn connection request WITHOUT a note (fastest & safest).
+
+    Assumes the profile page is already loaded (caller navigates via
+    ``get_connection_status`` or ``visit_profile`` beforehand).
+    """
+    public_identifier = profile.get('public_identifier')
+
+    # Send invitation WITHOUT note (current active flow)
+    if not _connect_direct(session) and not _connect_via_more(session):
+        logger.debug("Connect button not found for %s — staying at current stage", public_identifier)
+        dump_page_html(session, profile)
+        return ProfileState.QUALIFIED
+
+    _click_without_note(session)
+    _check_weekly_invitation_limit(session)
+
+    logger.debug("Connection request submitted for %s", public_identifier)
+    return ProfileState.PENDING
+
+
+def _check_weekly_invitation_limit(session):
+    weekly_invitation_limit = session.page.locator(SELECTORS["weekly_limit"])
+    if weekly_invitation_limit.count() > 0:
+        raise ReachedConnectionLimit("Weekly connection limit pop up appeared")
+
+
+def _connect_direct(session):
+    session.wait()
+    top_card = find_top_card(session)
+    direct = top_card.locator(SELECTORS["invite_to_connect"])
+    if direct.count() == 0:
+        return False
+
+    direct.first.click()
+    logger.debug("Clicked direct 'Connect' button")
+
+    error = session.page.locator(SELECTORS["error_toast"])
+    if error.count() > 0:
+        raise SkipProfile(f"{error.inner_text().strip()}")
+
+    return True
+
+
+def _connect_via_more(session):
+    session.wait()
+    top_card = find_top_card(session)
+    page = session.page
+
+    # Dropdown may render as a portal outside top_card, so search page-wide
+    connect_option = page.locator(SELECTORS["connect_option"])
+
+    # Connect option may already be visible (More dropdown opened by status check)
+    if connect_option.count() == 0:
+        more = top_card.locator(SELECTORS["more_button"])
+        if more.count() == 0:
+            return False
+        more.first.click()
+        session.wait()
+
+    connect_option = page.locator(SELECTORS["connect_option"])
+    if connect_option.count() == 0:
+        return False
+    connect_option.first.click()
+    logger.debug("Used 'More → Connect' flow")
+
+    return True
+
+
+def _click_without_note(session):
+    """Click flow: sends connection request instantly without note."""
+    session.wait()
+
+    # Click "Send now" / "Send without a note"
+    send_btn = session.page.locator(SELECTORS["send_now"])
+    send_btn.first.click(force=True)
+    session.wait()
+    logger.debug("Connection request submitted (no note)")