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

linkedin_cli/browser/login.py

@@ -0,0 +1,140 @@
+# linkedin/browser/login.py
+import logging
+import time
+
+from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+from playwright.sync_api import sync_playwright
+from playwright_stealth import Stealth
+from termcolor import colored
+
+from linkedin_cli.browser.nav import goto_page, human_type, resolve_locator
+from linkedin_cli.conf import (
+    BROWSER_DEFAULT_TIMEOUT_MS,
+    BROWSER_LOGIN_TIMEOUT_MS,
+    BROWSER_SLOW_MO,
+    CHECKPOINT_RESOLVE_TIMEOUT_S,
+)
+from linkedin_cli.page_state import PageState, classify_page
+
+CHECKPOINT_POLL_S = 5
+
+logger = logging.getLogger(__name__)
+
+LINKEDIN_LOGIN_URL = "https://www.linkedin.com/login"
+
+EMAIL_LOCATORS = [
+    lambda p: p.get_by_role("textbox", name="Email or phone"),
+    lambda p: p.get_by_label("Email or phone"),
+    lambda p: p.locator('input[autocomplete="webauthn"]'),
+    lambda p: p.locator('input[name="session_key"]'),
+    lambda p: p.locator('input#username'),
+    lambda p: p.locator('form input[type="text"]'),
+]
+
+PASSWORD_LOCATORS = [
+    lambda p: p.locator('input[type="password"]'),
+    lambda p: p.locator('input[autocomplete="current-password"]'),
+    lambda p: p.get_by_role("textbox", name="Password"),
+    lambda p: p.get_by_label("Password"),
+    lambda p: p.locator('input[name="session_password"]'),
+    lambda p: p.locator('input#password'),
+]
+
+SUBMIT_LOCATORS = [
+    lambda p: p.locator("form").get_by_role("button", name="Sign in", exact=True),
+    lambda p: p.get_by_role("button", name="Sign in", exact=True),
+    lambda p: p.locator('form button[type="submit"]'),
+    lambda p: p.locator('button[type="submit"]'),
+]
+
+COMPLY_LOCATORS = [
+    lambda p: p.locator('button#content__button--primary--muted'),
+    lambda p: p.get_by_role("button", name="Agree to comply", exact=True),
+    lambda p: p.locator('button.content__button--primary'),
+]
+
+COMPLY_PROBE_TIMEOUT_MS = 5000
+
+
+def dismiss_comply_gate(page, timeout_ms: int = COMPLY_PROBE_TIMEOUT_MS) -> bool:
+    """Click LinkedIn's 'Agree to comply' interstitial if present. Return True if clicked."""
+    for factory in COMPLY_LOCATORS:
+        locator = factory(page).first
+        try:
+            locator.wait_for(state="visible", timeout=timeout_ms)
+        except PlaywrightTimeoutError:
+            continue
+        logger.info(colored("Dismissing 'Agree to comply' interstitial", "yellow"))
+        locator.click()
+        return True
+    return False
+
+
+def await_checkpoint_clear(page, timeout_s: int = CHECKPOINT_RESOLVE_TIMEOUT_S) -> bool:
+    """Block while the user clears a LinkedIn checkpoint in the live browser.
+
+    The browser runs headed (noVNC at http://localhost:6080/vnc.html), so the
+    user can solve the challenge by hand. Returns True once the page leaves
+    ``/checkpoint/``, or False if it is still there after *timeout_s*. We never
+    resubmit credentials — every automated retry hardens the block; the only
+    escape is a human.
+    """
+    banner = "*" * 64
+    logger.error(colored(banner, "red", attrs=["bold"]))
+    logger.error(colored("  RESOLVE CHECKPOINT  ".center(64, "*"), "red", attrs=["bold"]))
+    logger.error(colored(banner, "red", attrs=["bold"]))
+    logger.error(
+        colored(
+            "Clear the challenge by hand in the live browser:",
+            "red", attrs=["bold"],
+        )
+    )
+    logger.error("Open the browser here: http://localhost:6080/vnc.html")
+    logger.error(f"Checkpoint URL: {page.url}")
+    logger.error(colored(banner, "red", attrs=["bold"]))
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if classify_page(page) is not PageState.CHECKPOINT:
+            logger.info(colored("Checkpoint cleared — continuing", "green", attrs=["bold"]))
+            return True
+        time.sleep(CHECKPOINT_POLL_S)
+    return False
+
+
+def submit_login_form(session, username, password):
+    """Fill and submit LinkedIn's login form (credentials supplied by the caller).
+
+    Does *not* assert the outcome — the caller (the auth flow's ``@transition``)
+    re-reads the page to decide what the submit produced: the feed, a checkpoint,
+    or, on rejected credentials, the login page again.
+    """
+    page = session.page
+    logger.info(colored("Submitting login form", "cyan") + f" for {session}")
+
+    goto_page(
+        session,
+        action=lambda: page.goto(LINKEDIN_LOGIN_URL),
+        expected_url_pattern="/login",
+        error_message="Failed to load login page",
+    )
+
+    human_type(resolve_locator(page, EMAIL_LOCATORS), username)
+    session.wait()
+    human_type(resolve_locator(page, PASSWORD_LOCATORS), password)
+    session.wait()
+
+    resolve_locator(page, SUBMIT_LOCATORS).click()
+    dismiss_comply_gate(page)
+    page.wait_for_load_state("domcontentloaded", timeout=BROWSER_LOGIN_TIMEOUT_MS)
+
+
+def launch_browser(storage_state=None):
+    logger.debug("Launching Playwright")
+    playwright = sync_playwright().start()
+    browser = playwright.chromium.launch(headless=False, slow_mo=BROWSER_SLOW_MO)
+    context = browser.new_context(storage_state=storage_state)
+    context.set_default_timeout(BROWSER_DEFAULT_TIMEOUT_MS)
+    context.set_default_navigation_timeout(BROWSER_DEFAULT_TIMEOUT_MS)
+    Stealth().apply_stealth_sync(context)
+    page = context.new_page()
+    return page, context, browser, playwright

linkedin_cli/browser/nav.py

@@ -0,0 +1,115 @@
+# linkedin/browser/nav.py
+import logging
+import random
+from urllib.parse import unquote, urlparse, urljoin
+
+from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+
+from linkedin_cli.conf import BROWSER_NAV_TIMEOUT_MS, DUMP_PAGES, FIXTURE_PAGES_DIR, HUMAN_TYPE_MIN_DELAY_MS, HUMAN_TYPE_MAX_DELAY_MS
+from linkedin_cli.exceptions import CheckpointChallengeError, SkipProfile
+
+logger = logging.getLogger(__name__)
+
+
+def goto_page(session,
+              action,
+              expected_url_pattern: str,
+              timeout: int = BROWSER_NAV_TIMEOUT_MS,
+              error_message: str = "",
+              ):
+    page = session.page
+    action()
+    if not page:
+        return
+
+    try:
+        page.wait_for_url(lambda url: expected_url_pattern in unquote(url), timeout=timeout)
+    except PlaywrightTimeoutError:
+        pass  # we still continue and check URL below
+
+    session.wait()
+
+    current = unquote(page.url)
+    if expected_url_pattern not in current:
+        if "/404" in current:
+            raise SkipProfile(f"Profile returned 404 → {current}")
+        raise RuntimeError(f"{error_message} → expected '{expected_url_pattern}' | got '{current}'")
+
+    logger.debug("Navigated to %s", page.url)
+
+
+def extract_in_urls(page):
+    """Extract all /in/ profile URLs from the current page."""
+    from linkedin_cli.url_utils import url_to_public_id
+
+    seen = set()
+    urls = []
+    for link in page.locator('a[href*="/in/"]').all():
+        href = link.get_attribute("href")
+        if href and "/in/" in href:
+            full_url = urljoin(page.url, href.strip())
+            clean = urlparse(full_url)._replace(query="", fragment="").geturl()
+            if not url_to_public_id(clean):
+                continue
+            if clean not in seen:
+                seen.add(clean)
+                urls.append(clean)
+    logger.debug(f"Extracted {len(urls)} unique /in/ profiles")
+    return urls
+
+
+def find_first_visible(page, selectors: list[str]):
+    """Try selectors in order, return first locator that matches."""
+    for selector in selectors:
+        locator = page.locator(selector)
+        if locator.count() > 0:
+            return locator.first
+    return None
+
+
+def resolve_locator(page, candidates, timeout_per_ms: int = 5000):
+    """Try locator factories in order, return the first one that becomes visible."""
+    for factory in candidates:
+        locator = factory(page).first
+        try:
+            locator.wait_for(state="visible", timeout=timeout_per_ms)
+            return locator
+        except PlaywrightTimeoutError:
+            continue
+    if "/checkpoint/" in page.url:
+        raise CheckpointChallengeError(page.url)
+    raise RuntimeError(f"No locator matched on {page.url}")
+
+
+TOP_CARD_SELECTORS = [
+    'section:has(div.top-card-background-hero-image)',
+    'section[data-member-id]',
+    'section.artdeco-card:has(> div.pv-top-card)',
+    'section:has(> div[class*="pv-top-card"])',
+    'section[componentkey*="com.linkedin.sdui.profile.card"]',
+]
+
+
+def find_top_card(session):
+    top_card = find_first_visible(session.page, TOP_CARD_SELECTORS)
+    if top_card is None:
+        logger.warning("Top card not found on %s", session.page.url)
+        raise SkipProfile("Top Card section not found")
+    return top_card
+
+
+def human_type(locator, text: str, min_delay: int = HUMAN_TYPE_MIN_DELAY_MS, max_delay: int = HUMAN_TYPE_MAX_DELAY_MS):
+    """Type text with randomized per-keystroke delay to mimic human input."""
+    locator.type(text, delay=random.randint(min_delay, max_delay))
+
+
+def dump_page_html(session: "LinkedInSession", profile: dict, category: str = "connect"):
+    if not DUMP_PAGES:
+        return
+    dest = FIXTURE_PAGES_DIR / category
+    dest.mkdir(parents=True, exist_ok=True)
+    filepath = dest / f"{profile.get('public_identifier')}.html"
+    html_content = session.page.content()
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(html_content)
+    logger.info("Saved page snapshot → %s", filepath)

linkedin_cli/cli.py

@@ -0,0 +1,396 @@
+"""linkedin-cli — drive LinkedIn interactions inside a bound browser session.
+
+``session open`` launches + binds a persistent browser (the session owner); the
+verbs connect to it and drive LinkedIn. One session = one account; pick it with
+``--session <name>`` (or ``$LINKEDIN_CLI_SESSION``).
+
+Output contract — design decisions, kept here so they travel with the package:
+
+* **Every verb produces a dict** — its canonical result. That one dict is both
+  the ``--json`` payload and the source the human renderer summarises, so the
+  two views can never drift.
+* **Human-readable by default; ``--json`` on every verb for the full dict.**
+  Per clig.dev ("humans first", "keep it brief, err toward less output"), the
+  default is a short, scannable per-verb summary (``status`` → ``Connected``,
+  ``profile`` → a few lines); ``--json`` emits the whole dict for machines.
+* **No ``--out``/file flag — print to stdout, let the caller redirect.** To save
+  a result: ``linkedin-cli profile alice --json > alice.json``. This matches the
+  composability convention (clig.dev; ``kubectl -o``, ``aws --output``,
+  ``gh --json``) and keeps the tool free of file-lifecycle concerns.
+* **stdout carries only the result; logs and errors go to stderr.** Errors are an
+  ``error: <type>: <message>`` line + non-zero exit (``type`` mirrors
+  ``exceptions.py``). A verb that ran is exit 0 — ``message`` reports send success
+  in its dict (``sent``), not via the exit code.
+
+This module is the composition root: it owns policy (e.g. interaction pacing)
+and injects it into the session — the session/action layers read no config.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import signal
+import sys
+
+from linkedin_cli.enums import ProfileState
+from linkedin_cli.exceptions import (
+    AuthenticationError,
+    CheckpointChallengeError,
+    ProfileInaccessibleError,
+    ReachedConnectionLimit,
+    SkipProfile,
+)
+from linkedin_cli.session import PlaywrightCliSession, linkedin_cli_home, read_session
+from linkedin_cli.url_utils import public_id_to_url, url_to_public_id
+
+logger = logging.getLogger("linkedin_cli")
+
+# Pacing policy lives here (the composition root), injected into the session.
+DEFAULT_MIN_PACE_S = 5.0
+DEFAULT_MAX_PACE_S = 8.0
+
+# Exception → contract error `type`, in match order.
+_ERROR_TYPES = [
+    (CheckpointChallengeError, "checkpoint_challenge"),
+    (AuthenticationError, "authentication"),
+    (ProfileInaccessibleError, "profile_inaccessible"),
+    (SkipProfile, "skip_profile"),
+    (ReachedConnectionLimit, "connection_limit"),
+]
+
+
+# ── output helpers ─────────────────────────────────────────────────
+
+def _out(text: str) -> None:
+    """Print a result line to stdout (the only thing that touches stdout)."""
+    sys.stdout.write(f"{text}\n")
+    sys.stdout.flush()
+
+
+def _err(text: str) -> None:
+    """Print a log/error line to stderr."""
+    print(text, file=sys.stderr)
+
+
+def _error_type(exc: Exception) -> str | None:
+    for cls, name in _ERROR_TYPES:
+        if isinstance(exc, cls):
+            return name
+    return None
+
+
+def _self_block(profile: dict) -> dict:
+    return {
+        "public_identifier": profile.get("public_identifier"),
+        "urn": profile.get("urn"),
+        "full_name": profile.get("full_name"),
+    }
+
+
+# ── human-readable rendering (the non-`--json` default) ─────────────
+#
+# clig.dev: "keep it brief", "err toward less output". Each verb gets a short,
+# scannable summary of its result dict; `--json` always emits the full dict.
+
+def _human_identity(result: dict) -> str:
+    member = result.get("self", result)
+    return f"{member.get('full_name')} ({member.get('public_identifier')})"
+
+
+def _human_state(result: dict) -> str:
+    return result.get("state", "")
+
+
+def _human_sent(result: dict) -> str:
+    return "sent" if result.get("sent") else "not sent"
+
+
+def _human_profile(result: dict) -> str:
+    industry = result.get("industry") or {}
+    subtitle = " · ".join(x for x in (
+        result.get("location_name"),
+        industry.get("name") if isinstance(industry, dict) else None,
+    ) if x)
+    lines = [" — ".join(x for x in (result.get("full_name"), result.get("headline")) if x)]
+    if subtitle:
+        lines.append(subtitle)
+    lines.append(f"{len(result.get('positions') or [])} positions · "
+                 f"{len(result.get('educations') or [])} schools")
+    lines.append("(--json for the full record)")
+    return "\n".join(lines)
+
+
+def _human_thread(result: dict) -> str:
+    messages = result.get("messages")
+    if not messages:
+        return "(no conversation)"
+    return "\n".join(
+        f"{m.get('timestamp', '')}  {m.get('sender', '')}: {m.get('text', '')}"
+        for m in messages
+    )
+
+
+def _human_search(result: dict) -> str:
+    profiles = result.get("profiles") or []
+    if not profiles:
+        return "(no results)"
+    header = f"{len(profiles)} result(s) on page {result.get('page', 1)}:"
+    return "\n".join([header] + [f"  {p['public_identifier']}" for p in profiles])
+
+
+def _human_closed(result: dict) -> str:
+    return f"closed {result.get('name')}"
+
+
+_HUMAN = {
+    "login": _human_identity,
+    "whoami": _human_identity,
+    "status": _human_state,
+    "connect": _human_state,
+    "message": _human_sent,
+    "profile": _human_profile,
+    "thread": _human_thread,
+    "search": _human_search,
+    "session-close": _human_closed,
+}
+
+
+def _render(command: str, result: dict, as_json: bool) -> None:
+    """Print *result*: the full dict as JSON if ``--json``, else a brief summary."""
+    if as_json:
+        _out(json.dumps(result, ensure_ascii=False, default=str))
+        return
+    renderer = _HUMAN.get(command)
+    _out(renderer(result) if renderer
+         else "\n".join(f"{k}: {v}" for k, v in result.items()))
+
+
+def _handle_to_profile(handle: str) -> dict:
+    """Build a minimal ``{public_identifier, url}`` from a <url|id> handle."""
+    public_id = url_to_public_id(handle) if "/" in handle else handle
+    if not public_id:
+        raise ValueError(f"Could not resolve a public identifier from {handle!r}")
+    return {"public_identifier": public_id, "url": public_id_to_url(public_id)}
+
+
+def _scrape(session, handle: str) -> dict:
+    """Scrape the target so urn-dependent verbs (message/thread) have its ``urn``."""
+    from linkedin_cli.actions.profile import scrape_profile
+
+    profile, _data = scrape_profile(session, _handle_to_profile(handle))
+    if not profile:
+        raise ProfileInaccessibleError(handle)
+    return profile
+
+
+# ── verbs ──────────────────────────────────────────────────────────
+
+def _verb_login(session, args) -> dict:
+    from linkedin_cli.auth import authenticate
+
+    authenticate(session)
+    return {"account": args.name, "self": _self_block(session.self_profile)}
+
+
+def _verb_whoami(session, args) -> dict:
+    return {"self": _self_block(session.self_profile)}
+
+
+def _verb_profile(session, args) -> dict:
+    from linkedin_cli.actions.profile import scrape_profile
+
+    profile, data = scrape_profile(session, _handle_to_profile(args.handle))
+    if not profile:
+        raise ProfileInaccessibleError(args.handle)
+    out = dict(profile)
+    if args.raw:
+        out["_raw"] = data
+    return out
+
+
+def _verb_status(session, args) -> dict:
+    from linkedin_cli.actions.status import get_connection_status
+
+    profile = _handle_to_profile(args.handle)
+    state = get_connection_status(session, profile)
+    return {"public_identifier": profile["public_identifier"], "state": state.value}
+
+
+def _verb_connect(session, args) -> dict:
+    from linkedin_cli.actions.connect import send_connection_request
+    from linkedin_cli.actions.status import get_connection_status
+
+    profile = _handle_to_profile(args.handle)
+    state = get_connection_status(session, profile)
+    if state not in (ProfileState.CONNECTED, ProfileState.PENDING):
+        state = send_connection_request(session, profile)
+    return {"public_identifier": profile["public_identifier"], "state": state.value}
+
+
+def _verb_message(session, args) -> dict:
+    from linkedin_cli.actions.message import send_raw_message
+
+    profile = _scrape(session, args.handle)
+    sent = send_raw_message(session, profile, args.text)
+    return {"public_identifier": profile.get("public_identifier"), "sent": sent}
+
+
+def _verb_thread(session, args) -> dict:
+    from linkedin_cli.actions.conversations import get_conversation
+
+    profile = _scrape(session, args.handle)
+    messages = get_conversation(session, profile.get("urn"), session.self_profile["urn"])
+    return {"public_identifier": profile.get("public_identifier"), "messages": messages}
+
+
+def _verb_search(session, args) -> dict:
+    from linkedin_cli.actions.search import NETWORK_CODES, search_people
+
+    codes = [NETWORK_CODES[n] for n in (args.network or [])]
+    return search_people(session, args.keywords, page=args.page, network=codes or None)
+
+
+_VERBS = {
+    "login": _verb_login,
+    "whoami": _verb_whoami,
+    "profile": _verb_profile,
+    "status": _verb_status,
+    "connect": _verb_connect,
+    "message": _verb_message,
+    "thread": _verb_thread,
+    "search": _verb_search,
+}
+
+
+# ── session lifecycle commands ─────────────────────────────────────
+
+def _cmd_session_open(args) -> int:
+    from linkedin_cli.launcher import open_bound_session
+
+    profile_dir = str(linkedin_cli_home() / "profiles" / args.name)
+    open_bound_session(args.name, profile_dir=profile_dir)
+    return 0
+
+
+def _cmd_session_close(args) -> int:
+    record = read_session(args.name)
+    if not record:
+        _err(f"error: usage: no open session named {args.name!r}")
+        return 2
+    os.kill(record["pid"], signal.SIGTERM)
+    _render("session-close", {"name": args.name, "closed": True}, args.json)
+    return 0
+
+
+# ── verb runner ────────────────────────────────────────────────────
+
+def _run_verb(args) -> int:
+    record = read_session(args.name)
+    if not record:
+        _err(f"error: usage: no open session named {args.name!r} — run "
+             f"`linkedin-cli session open --session {args.name}`")
+        return 2
+
+    session = PlaywrightCliSession(
+        record["endpoint"],
+        min_pace=DEFAULT_MIN_PACE_S,
+        max_pace=DEFAULT_MAX_PACE_S,
+        username=os.environ.get("LINKEDIN_USERNAME"),
+        password=os.environ.get("LINKEDIN_PASSWORD"),
+        name=args.name,
+    )
+    try:
+        session.ensure_browser()
+        _render(args.verb, _VERBS[args.verb](session, args), args.json)
+        return 0
+    except Exception as exc:  # noqa: BLE001 — map known errors, re-raise the rest
+        error_type = _error_type(exc)
+        if error_type is None:
+            raise
+        _err(f"error: {error_type}: {exc}")
+        return 1
+    finally:
+        session.close()
+
+
+# ── parser ─────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument(
+        "--session", "--name", dest="name",
+        default=os.environ.get("LINKEDIN_CLI_SESSION", "default"),
+        help="Bound session name (default: $LINKEDIN_CLI_SESSION or 'default')",
+    )
+    common.add_argument(
+        "--json", action="store_true",
+        help="Emit the full result as JSON instead of a human-readable summary",
+    )
+
+    parser = argparse.ArgumentParser(prog="linkedin-cli", description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    # session open / close
+    session_cmd = sub.add_parser("session", help="Manage the bound browser session")
+    session_sub = session_cmd.add_subparsers(dest="subcmd", required=True)
+    session_sub.add_parser("open", parents=[common], help="Launch + bind a persistent browser, then block")
+    session_sub.add_parser("close", parents=[common], help="Signal the session launcher to shut down")
+
+    # verbs
+    handle_help = "Profile URL or public identifier (e.g. alice-smith)"
+
+    sub.add_parser("login", parents=[common],
+                   help="Log the session in (fill the form, clear a checkpoint) and report the logged-in member")
+    sub.add_parser("whoami", parents=[common],
+                   help="Report who the session is logged in as — no login, no checkpoint")
+
+    p_profile = sub.add_parser("profile", parents=[common],
+                               help="Scrape a member's full profile: headline, positions, education, location")
+    p_profile.add_argument("handle", help=handle_help)
+    p_profile.add_argument("--raw", action="store_true", help="Also emit the untouched Voyager blob under _raw")
+
+    sub.add_parser("status", parents=[common],
+                   help="Report the connection state with the member: Connected, Pending, or Qualified"
+                   ).add_argument("handle", help=handle_help)
+    sub.add_parser("connect", parents=[common],
+                   help="Send a connection request (no note); no-op if already Connected or Pending"
+                   ).add_argument("handle", help=handle_help)
+    sub.add_parser("thread", parents=[common],
+                   help="Dump the conversation with the member as a list of messages (newest last)"
+                   ).add_argument("handle", help=handle_help)
+
+    p_message = sub.add_parser("message", parents=[common],
+                               help="Send a direct message to the member")
+    p_message.add_argument("handle", help=handle_help)
+    p_message.add_argument("--text", required=True, help="Message body to send")
+
+    p_search = sub.add_parser("search", parents=[common],
+                              help="Search People by keyword; list matching profile handles")
+    p_search.add_argument("keywords", help="Search keywords, e.g. 'San Francisco'")
+    p_search.add_argument("--network", action="append", choices=["first", "second", "third"],
+                          help="Filter by connection degree (repeatable): first / second / third")
+    p_search.add_argument("--page", type=int, default=1, help="Result page (default: 1)")
+    return parser
+
+
+def _configure_logging() -> None:
+    level = os.environ.get("LINKEDIN_CLI_LOG", "INFO").upper()
+    logging.basicConfig(level=level, stream=sys.stderr,
+                        format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    _configure_logging()
+
+    if args.cmd == "session":
+        return _cmd_session_open(args) if args.subcmd == "open" else _cmd_session_close(args)
+
+    args.verb = args.cmd
+    return _run_verb(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

linkedin_cli/conf.py

@@ -0,0 +1,33 @@
+"""Platform constants for the LinkedIn interaction layer.
+
+Browser timing/launch knobs and fixture paths — no campaign, CRM, or
+scheduling config (that stays in OpenOutreach's ``linkedin/conf.py``).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).parent.parent
+
+# ----------------------------------------------------------------------
+# Fixture paths (saved HTML pages + profile JSON for tests/fixture capture)
+# ----------------------------------------------------------------------
+FIXTURE_DIR = ROOT_DIR / "tests" / "fixtures"
+FIXTURE_PROFILES_DIR = FIXTURE_DIR / "profiles"
+FIXTURE_PAGES_DIR = FIXTURE_DIR / "pages"
+DUMP_PAGES = False
+
+# ----------------------------------------------------------------------
+# Browser config
+# ----------------------------------------------------------------------
+BROWSER_HEADLESS = False  # LinkedIn runs headed (under Xvfb in Docker)
+BROWSER_SLOW_MO = 200
+BROWSER_DEFAULT_TIMEOUT_MS = 30_000
+BROWSER_LOGIN_TIMEOUT_MS = 40_000
+BROWSER_NAV_TIMEOUT_MS = 10_000
+HUMAN_TYPE_MIN_DELAY_MS = 50
+HUMAN_TYPE_MAX_DELAY_MS = 200
+
+# Seconds to wait for the user to clear a LinkedIn security checkpoint in the
+# live browser (noVNC http://localhost:6080/vnc.html) before the daemon exits.
+CHECKPOINT_RESOLVE_TIMEOUT_S = 1800