@alfe.ai/openclaw-linkedin 0.1.0

package/python/supervisor.py

@@ -0,0 +1,149 @@
+"""Own the worker's unreaped PID until its private process group is quiescent.
+
+The supervisor is outside that group. Only it may signal the group, and it
+never reaps its direct child until the last signal and liveness check finish.
+Node sends cancellation and receives the cleanup acknowledgement over fd 3;
+the worker never inherits that channel. No provider data crosses this channel.
+"""
+
+import os
+import re
+import select
+import signal
+import subprocess
+import sys
+import time
+
+CONTROL_FD = 3
+
+
+def observe_child(pid):
+    # WNOWAIT preserves the PID reservation, including after the leader exits.
+    # Never use Popen.poll()/wait() or a reaping SIGCHLD handler for this child.
+    return os.waitid(os.P_PID, pid, os.WEXITED | os.WNOHANG | os.WNOWAIT)
+
+
+def signal_owned_group(pid, value):
+    # Losing wait ownership must fail closed, not signal a possibly reused ID.
+    observe_child(pid)
+    try:
+        os.killpg(pid, value)
+    except (ProcessLookupError, PermissionError):
+        # Darwin reports EPERM for an all-zombie group. The independent state
+        # check still must prove quiescence; a live inaccessible group parks.
+        pass
+
+
+def process_snapshot():
+    """Use the exact same bounded process inspection for readiness and cleanup."""
+    result = subprocess.run(
+        ["/bin/ps", "-axo", "pgid=,stat="],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        check=True,
+        timeout=5,
+        text=True,
+    )
+    rows = [line.split() for line in result.stdout.splitlines() if line.strip()]
+    if not rows or any(
+        len(row) != 2
+        or not re.fullmatch(r"[0-9]+", row[0])
+        or not re.fullmatch(r"[RSDTtZXIWUPEN][A-Za-z<>+]*", row[1])
+        for row in rows
+    ):
+        raise ValueError("Process inspection output is incompatible")
+    # Empty/truncated output must not masquerade as an absent worker group.
+    # This inspector is running and must be visible in its own process table.
+    if not any(int(row[0]) == os.getpgrp() for row in rows):
+        raise ValueError("Process inspection omitted the inspector")
+    return rows
+
+
+def group_is_quiescent(pid):
+    # The leader stays waitable while ps runs, so this PGID cannot be recycled.
+    # Already-dead orphan zombies cannot retain browser sockets or fork again.
+    try:
+        rows = process_snapshot()
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return False
+    group = [row for row in rows if int(row[0]) == pid]
+    # The unreaped leader must still appear, even as a zombie. An absent group
+    # is incomplete inspection, not proof that our reserved identity vanished.
+    return bool(group) and all(row[1].startswith(("Z", "X")) for row in group)
+
+
+def supervise(pid, control_fd, grace_seconds):
+    stopping_at = None
+    control_open = True
+    while True:
+        status = observe_child(pid)
+        now = time.monotonic()
+        if status is not None or (stopping_at is not None and now >= stopping_at + grace_seconds):
+            signal_owned_group(pid, signal.SIGKILL)
+            if observe_child(pid) is not None and group_is_quiescent(pid):
+                # This is the ONLY reaping call, and no signaling follows it.
+                _, wait_status = os.waitpid(pid, 0)
+                return os.waitstatus_to_exitcode(wait_status)
+
+        if control_open:
+            readable, _, _ = select.select([control_fd], [], [], 0.025)
+            if readable:
+                command = os.read(control_fd, 64)
+                if not command:
+                    control_open = False
+                # Any control input (or parent EOF) cancels the exact operation.
+                if stopping_at is None:
+                    stopping_at = time.monotonic()
+                    signal_owned_group(pid, signal.SIGTERM)
+        else:
+            time.sleep(0.025)
+
+
+def main():
+    if sys.argv[1:] == ["--check"]:
+        # No worker/browser capability exists during this preflight. Do not
+        # reuse the unavailable/quiescent control acknowledgements here.
+        try:
+            process_snapshot()
+        except (OSError, ValueError, subprocess.SubprocessError):
+            return 78
+        print("ready")
+        return 0
+
+    required = ("fork", "setsid", "waitid", "WNOWAIT", "WEXITED", "WNOHANG", "P_PID")
+    if not all(hasattr(os, name) for name in required):
+        # No worker exists, so Node can safely reject this unsupported runtime.
+        os.write(CONTROL_FD, b"unavailable\n")
+        return 78
+
+    signal.signal(signal.SIGCHLD, signal.SIG_DFL)
+    ready_read, ready_write = os.pipe()
+    pid = os.fork()
+    if pid == 0:
+        try:
+            os.close(CONTROL_FD)
+            os.close(ready_read)
+            os.setsid()
+            os.write(ready_write, b"ready")
+            os.close(ready_write)
+            os.execv(sys.executable, [sys.executable, "-I", sys.argv[1]])
+        finally:
+            os._exit(127)
+
+    os.close(ready_write)
+    ready = os.read(ready_read, 5)
+    os.close(ready_read)
+    if ready != b"ready":
+        # The child did not reach exec and therefore could not create a driver.
+        os.waitpid(pid, 0)
+        os.write(CONTROL_FD, b"quiescent\n")
+        return 127
+
+    exit_code = supervise(pid, CONTROL_FD, float(sys.argv[2]) / 1000)
+    # The callback must not settle on stdout alone, or on an unacknowledged exit.
+    os.write(CONTROL_FD, b"quiescent\n")
+    return exit_code if exit_code >= 0 else 128 - exit_code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/python/worker.py

@@ -0,0 +1,235 @@
+"""One bounded extraction against an exact Alfe-owned browser target.
+
+No MCP bootstrap, authentication manager, cookie import, browser launch or close.
+The Node owner holds its shared operation gate until this process and driver exit.
+"""
+import asyncio
+import importlib.metadata
+import json
+import logging
+import os
+import re
+import signal
+import sys
+from urllib.parse import urljoin, urlparse, urlunparse
+
+# Set before importing upstream; explicit debug dirs override trace_mode upstream.
+os.environ["LINKEDIN_TRACE_MODE"] = "off"
+os.environ["LINKEDIN_DEBUG_TRACE_DIR"] = ""
+os.environ["PYTHON_DOTENV_DISABLED"] = "1"
+logging.disable(logging.CRITICAL)
+
+EXTRACTOR_VERSION = "4.24.0"
+PATCHRIGHT_VERSION = "1.61.2"
+DOTENV_VERSION = "1.2.3"
+MAX_INPUT = 24 * 1024
+MAX_OUTPUT = 384 * 1024
+
+
+class RequestError(Exception):
+    pass
+
+
+def validate_request(value):
+    if not isinstance(value, dict):
+        raise RequestError()
+    endpoint = value.get("browserWSEndpoint")
+    target = value.get("targetId")
+    parsed = urlparse(endpoint) if isinstance(endpoint, str) else None
+    if (not parsed or parsed.scheme != "ws" or parsed.hostname not in ("127.0.0.1", "localhost", "::1")
+            or parsed.username or parsed.password or not parsed.path.startswith("/devtools/browser/")
+            or parsed.query or parsed.fragment or len(endpoint) > 2048):
+        raise RequestError()
+    if not isinstance(target, str) or not re.fullmatch(r"[A-Za-z0-9_-]{1,128}", target):
+        raise RequestError()
+    if value.get("action") not in ("status", "login", "inbox", "conversation", "search", "prepare_message", "send_message"):
+        raise RequestError()
+    params = value.get("params", {})
+    if not isinstance(params, dict):
+        raise RequestError()
+    action = value["action"]
+    if action in ("inbox", "search"):
+        limit = params.get("limit", 20)
+        if type(limit) is not int or not 1 <= limit <= 50:
+            raise RequestError()
+    if action == "search":
+        bounded_string(params, "keywords", 200)
+    if action == "conversation":
+        from linkedin_mcp_server.scraping.identifiers import normalize_thread_id
+        params["threadId"] = normalize_reference(bounded_string(params, "threadId", 2048), normalize_thread_id)
+    if action in ("prepare_message", "send_message"):
+        from linkedin_mcp_server.scraping.identifiers import normalize_person_identifier
+        params["username"] = normalize_reference(bounded_string(params, "username", 2048), normalize_person_identifier)
+        if len(params["username"]) > 100:
+            raise RequestError()
+        bounded_string(params, "message", 3000)
+        if action == "send_message" and params.get("confirm") is not True:
+            raise RequestError()
+    return value
+
+
+def normalize_reference(value, normalizer):
+    if "://" in value:
+        parsed = urlparse(value)
+        if parsed.scheme != "https" or parsed.hostname != "www.linkedin.com" or parsed.username or parsed.password or parsed.port:
+            raise RequestError()
+    try:
+        return normalizer(value)
+    except Exception:
+        raise RequestError() from None
+
+
+def bounded_string(params, key, maximum):
+    value = params.get(key)
+    if not isinstance(value, str) or not value.strip() or len(value) > maximum or "\x00" in value:
+        raise RequestError()
+    return value
+
+
+async def exact_page(browser, target_id):
+    """Enumerate all attached pages, then match Chrome target identity, never order."""
+    matches = []
+    for context in browser.contexts:
+        for page in context.pages:
+            if page.is_closed():
+                continue
+            session = await context.new_cdp_session(page)
+            try:
+                info = await session.send("Target.getTargetInfo")
+                if info.get("targetInfo", {}).get("targetId") == target_id:
+                    matches.append(page)
+            finally:
+                await session.detach()
+    if len(matches) != 1 or matches[0].is_closed():
+        raise RequestError()
+    return matches[0]
+
+
+def project_read(result):
+    sections = {}
+    budget = 120_000
+    for key, value in result.get("sections", {}).items():
+        if key in ("inbox", "conversation", "search_results") and isinstance(value, str):
+            sections[key] = value[:budget]
+            budget -= len(sections[key])
+    references = []
+    for items in result.get("references", {}).values():
+        if not isinstance(items, list):
+            continue
+        for item in items:
+            if not isinstance(item, dict) or not isinstance(item.get("url"), str):
+                continue
+            parsed = urlparse(urljoin("https://www.linkedin.com", item["url"]))
+            if parsed.scheme != "https" or parsed.hostname != "www.linkedin.com" or parsed.username or parsed.password or parsed.port:
+                continue
+            url = urlunparse(("https", "www.linkedin.com", parsed.path, "", "", ""))
+            if len(url) > 2048:
+                continue
+            label = item.get("label", item.get("text", "LinkedIn reference"))
+            references.append({"label": str(label)[:300], "url": url})
+            if len(references) >= 100:
+                break
+        if len(references) >= 100:
+            break
+    return {"status": "ok", "sections": sections, "references": references}
+
+
+async def perform(page, request, extractor_class, detect_auth_barrier, is_logged_in):
+    action = request["action"]
+    params = request.get("params", {})
+    if action == "login":
+        await page.goto("https://www.linkedin.com/login", wait_until="domcontentloaded", timeout=30_000)
+        return {"status": "needs_login", "code": "needs_login"}
+    if action == "status":
+        await page.goto("https://www.linkedin.com/feed/", wait_until="domcontentloaded", timeout=30_000)
+        host = urlparse(page.url).hostname
+        if host != "www.linkedin.com" or await detect_auth_barrier(page) or not await is_logged_in(page):
+            return {"status": "needs_login", "code": "needs_login"}
+        return {"status": "ready"}
+
+    class SharedPageExtractor(extractor_class):
+        async def _goto_with_auth_checks(self, url, *, wait_until="domcontentloaded", allow_remember_me=False):
+            # Never click an account chooser or try to repair authentication.
+            # This narrow override is version-pinned and covered by a contract test.
+            return await super()._goto_with_auth_checks(url, wait_until=wait_until, allow_remember_me=False)
+
+    extractor = SharedPageExtractor(page)
+    if action == "inbox":
+        return project_read(await extractor.get_inbox(limit=params.get("limit", 20)))
+    if action == "conversation":
+        return project_read(await extractor.get_conversation(thread_id=params["threadId"]))
+    if action == "search":
+        return project_read(await extractor.search_conversations(params["keywords"], limit=params.get("limit", 20)))
+    if action in ("prepare_message", "send_message"):
+        sending = action == "send_message"
+        result = await extractor.send_message(params["username"], params["message"], confirm_send=sending)
+        if not sending:
+            if result.get("status") == "confirmation_required" and result.get("recipient_selected") is True:
+                return {"status": "prepared", "username": params["username"]}
+            return {"status": "error", "code": "recipient_unavailable"}
+        if result.get("status") == "sent" and result.get("sent") is True and result.get("recipient_selected") is True:
+            return {"status": "sent"}
+        return {"status": "error", "code": "send_unknown"}
+    raise RequestError()
+
+
+async def run(request):
+    from patchright.async_api import async_playwright, TimeoutError as DriverTimeout
+    from linkedin_mcp_server.scraping.extractor import LinkedInExtractor
+    from linkedin_mcp_server.core.auth import detect_auth_barrier, is_logged_in
+    from linkedin_mcp_server.core.exceptions import AuthenticationError, RateLimitError, NetworkError, ProfileNotFoundError
+
+    current = asyncio.current_task()
+    loop = asyncio.get_running_loop()
+    if os.name != "nt":
+        loop.add_signal_handler(signal.SIGTERM, current.cancel)
+    driver = await async_playwright().start()
+    try:
+        browser = await driver.chromium.connect_over_cdp(request["browserWSEndpoint"], no_defaults=True, timeout=15_000)
+        page = await exact_page(browser, request["targetId"])
+        try:
+            return await perform(page, request, LinkedInExtractor, detect_auth_barrier, is_logged_in)
+        except AuthenticationError:
+            return {"status": "needs_login", "code": "needs_login"}
+        except RateLimitError:
+            return {"status": "error", "code": "rate_limited"}
+        except ProfileNotFoundError:
+            return {"status": "error", "code": "page_unavailable"}
+        except (NetworkError, DriverTimeout):
+            return {"status": "error", "code": "send_unknown" if request["action"] == "send_message" else "network_error"}
+    finally:
+        # Patchright.stop tears down this connection/driver, not Alfe's browser.
+        # Calling Browser.close, Context.close or Page.close here is forbidden.
+        await driver.stop()
+
+
+def main():
+    try:
+        raw = sys.stdin.buffer.read(MAX_INPUT + 1)
+        if len(raw) > MAX_INPUT:
+            raise RequestError()
+        unvalidated = json.loads(raw)
+        if (importlib.metadata.version("mcp-server-linkedin") != EXTRACTOR_VERSION
+                or importlib.metadata.version("patchright") != PATCHRIGHT_VERSION
+                or importlib.metadata.version("python-dotenv") != DOTENV_VERSION):
+            result = {"status": "error", "code": "runtime_mismatch"}
+        else:
+            # Identifier normalization imports upstream too. Verify before ANY
+            # such import, including validation-only and mutation input paths.
+            request = validate_request(unvalidated)
+            result = asyncio.run(run(request))
+    except (RequestError, json.JSONDecodeError, UnicodeDecodeError):
+        result = {"status": "error", "code": "invalid_request"}
+    except importlib.metadata.PackageNotFoundError:
+        result = {"status": "error", "code": "runtime_mismatch"}
+    except Exception:
+        result = {"status": "error", "code": "extraction_failed"}
+    encoded = json.dumps(result, ensure_ascii=False).encode("utf-8")
+    if len(encoded) > MAX_OUTPUT:
+        encoded = b'{"status":"error","code":"extraction_failed"}'
+    sys.stdout.buffer.write(encoded)
+    sys.stdout.buffer.flush()
+
+
+if __name__ == "__main__":
+    main()