agent-wire-cli 0.2.1__py3-none-any.whl

agent_wire/channels/tier2_pro/fediverse.py

@@ -0,0 +1,181 @@
+"""Bluesky (public AT Protocol AppView) and Mastodon (ActivityPub REST), zero auth."""
+
+from urllib.parse import quote, urlsplit
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_to_markdown, listing, ts
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.models import WireComment, WireSearchHit
+
+BSKY = "https://api.bsky.app/xrpc"  # public.api.bsky.app 403s searchPosts for anonymous callers
+
+
+def _bsky_url(post: dict) -> str:
+    rkey = post.get("uri", "").rsplit("/", 1)[-1]
+    return f"https://bsky.app/profile/{post.get('author', {}).get('handle')}/post/{rkey}"
+
+
+def _bsky_hit(p: dict) -> WireSearchHit:
+    handle = p.get("author", {}).get("handle")
+    return WireSearchHit(
+        url=_bsky_url(p), title=f"@{handle}", snippet=p.get("record", {}).get("text", ""),
+        source="bluesky", rank_score=float(p.get("likeCount") or 0),
+        timestamp=ts(p.get("record", {}).get("createdAt")), author=handle,
+        engagement={"likes": p.get("likeCount") or 0, "reposts": p.get("repostCount") or 0,
+                    "comments": p.get("replyCount") or 0},
+    )  # fmt: skip
+
+
+def parse_bsky_thread(
+    thread: dict, op: str | None = None, depth: int = 0
+) -> tuple[dict, list[WireComment]]:
+    post = thread.get("post", {})
+    author = post.get("author", {}).get("handle")
+    replies = [
+        WireComment(
+            id=r["post"]["cid"], body=r["post"].get("record", {}).get("text", ""),
+            author_handle=r["post"].get("author", {}).get("handle"), score=r["post"].get("likeCount") or 0,
+            timestamp=ts(r["post"].get("record", {}).get("createdAt")), depth=depth,
+            is_op=r["post"].get("author", {}).get("handle") == (op or author),
+            replies=parse_bsky_thread(r, op or author, depth + 1)[1],
+        )
+        for r in thread.get("replies") or [] if r.get("post")
+    ]  # fmt: skip
+    return post, replies
+
+
+def parse_mastodon_context(descendants: list[dict], root_id: str, op: str) -> list[WireComment]:
+    children: dict[str, list[dict]] = {}
+    for s in descendants:
+        children.setdefault(s.get("in_reply_to_id"), []).append(s)
+
+    def build(parent: str, depth: int) -> list[WireComment]:
+        return [WireComment(id=s["id"], body=html_to_markdown(s.get("content", "")),
+                            author_handle=s.get("account", {}).get("acct"), score=s.get("favourites_count") or 0,
+                            timestamp=ts(s.get("created_at")), depth=depth,
+                            is_op=s.get("account", {}).get("acct") == op, replies=build(s["id"], depth + 1))
+                for s in children.get(parent, [])]  # fmt: skip
+
+    return build(root_id, 0)
+
+
+class FediverseChannel(Channel):
+    name = "fediverse"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        p = urlsplit(url)
+        segs = [s for s in p.path.split("/") if s]
+        if (p.hostname or "").endswith("bsky.app"):
+            if len(segs) >= 4 and segs[0] == "profile" and segs[2] == "post":
+                return await self._bsky_post(url, segs[1], segs[3])
+            if len(segs) >= 2 and segs[0] == "profile":
+                return await self.feed(f"bsky:{segs[1]}")
+            raise WireUnsupported("bluesky: expected /profile/<handle>[/post/<id>]")
+        if segs and segs[0].startswith("@") and len(segs) > 1 and segs[1].isdigit():
+            return await self._mastodon(url, f"https://{p.hostname}", segs[1], include_comments)
+        if len(segs) == 1 and segs[0].startswith("@"):  # profile; may not be a Mastodon host
+            who = segs[0] if "@" in segs[0][1:] else f"{segs[0]}@{p.hostname}"
+            try:
+                return await self.feed(who)
+            except (WireFetchError, ValueError, KeyError, TypeError):
+                pass
+        return await self.ctx.channel("web").read(url, query=query, section=section)
+
+    async def _did(self, actor: str) -> str:
+        if actor.startswith("did:"):
+            return actor
+        data, _ = await self.fetch_json(f"{BSKY}/com.atproto.identity.resolveHandle?handle={actor}")
+        return data["did"]
+
+    async def _bsky_post(self, url, actor, rkey):
+        did = await self._did(actor)
+        uri = f"at://{did}/app.bsky.feed.post/{rkey}"
+        data, f = await self.fetch_json(
+            f"{BSKY}/app.bsky.feed.getPostThread?uri={quote(uri)}&depth=6"
+        )
+        post, replies = parse_bsky_thread(data.get("thread", {}))
+        record = post.get("record", {})
+        embed = (post.get("embed") or {}).get("external") or {}
+        body = record.get("text", "") + (
+            f"\n\nLink: {embed['uri']} ({embed.get('title', '')})" if embed.get("uri") else ""
+        )
+        return self.doc(
+            f, url, title=f"@{post.get('author', {}).get('handle')} on Bluesky",
+            author_handle=post.get("author", {}).get("handle"), timestamp=ts(record.get("createdAt")),
+            score=post.get("likeCount"), body=body, comments=replies,
+            metadata={"likes": post.get("likeCount"), "reposts": post.get("repostCount"),
+                      "replies": post.get("replyCount")},
+        )  # fmt: skip
+
+    async def _mastodon(self, url, base, status_id, include_comments):
+        status, f = await self.fetch_json(f"{base}/api/v1/statuses/{status_id}")
+        op = status.get("account", {}).get("acct")
+        comments = []
+        if include_comments:
+            ctx, _ = await self.fetch_json(f"{base}/api/v1/statuses/{status_id}/context")
+            comments = parse_mastodon_context(ctx.get("descendants", []), status_id, op)
+        return self.doc(
+            f, url, title=f"@{op} on {urlsplit(base).hostname}", author_handle=op,
+            timestamp=ts(status.get("created_at")), score=status.get("favourites_count"),
+            body=html_to_markdown(status.get("content", "")), comments=comments,
+            metadata={"boosts": status.get("reblogs_count"), "replies": status.get("replies_count")},
+        )  # fmt: skip
+
+    async def search(self, query, *, limit=5, sort="relevance", since=None):
+        order = "latest" if sort in ("new", "latest") else "top"
+        window = f"&since={since.strftime('%Y-%m-%dT%H:%M:%SZ')}" if since else ""
+        data, _ = await self.fetch_json(
+            f"{BSKY}/app.bsky.feed.searchPosts?q={quote(query)}&limit={limit}&sort={order}{window}"
+        )
+        return [_bsky_hit(p) for p in data.get("posts", [])]
+
+    async def mastodon_tag(self, tag: str, *, limit=10, instance="mastodon.social"):
+        """Public hashtag timeline (no auth on most instances)."""
+        tag = "".join(ch for ch in tag if ch.isalnum() or ch == "_")
+        data, _ = await self.fetch_json(
+            f"https://{instance}/api/v1/timelines/tag/{tag}?limit={limit}"
+        )
+        hits = []
+        for s in data:
+            s = s.get("reblog") or s
+            acct = (s.get("account") or {}).get("acct")
+            hits.append(WireSearchHit(
+                url=s.get("url") or s.get("uri", ""), title=f"@{acct}",
+                snippet=html_to_markdown(s.get("content", ""))[:300], source="mastodon",
+                rank_score=float(s.get("favourites_count") or 0), timestamp=ts(s.get("created_at")),
+                author=acct, engagement={"likes": s.get("favourites_count") or 0,
+                                         "reposts": s.get("reblogs_count") or 0,
+                                         "comments": s.get("replies_count") or 0},
+            ))  # fmt: skip
+        return hits
+
+    async def feed(self, target, *, sort="hot", limit=10):
+        t = target.strip().removeprefix("bsky:")
+        if t.count("@") == 2 or (t.startswith("@") and "@" in t[1:]):  # @user@instance -> Mastodon
+            user, instance = t.lstrip("@").split("@", 1)
+            base = f"https://{instance}"
+            acct, f = await self.fetch_json(f"{base}/api/v1/accounts/lookup?acct={user}")
+            statuses, f = await self.fetch_json(
+                f"{base}/api/v1/accounts/{acct['id']}/statuses?limit={limit}&exclude_replies=true"
+            )
+            statuses = [s.get("reblog") or s for s in statuses]  # boosts carry their content inside
+            items = [{"title": html_to_markdown(s.get("content", ""))[:120] or s.get("url"), "url": s.get("url"),
+                      "meta": [f"♥{s.get('favourites_count', 0)}", f"↻{s.get('reblogs_count', 0)}",
+                               (s.get("created_at") or "")[:10]]} for s in statuses]  # fmt: skip
+            return self.doc(f, f"{base}/@{user}", title=f"@{user}@{instance}", body=listing(items))
+        actor = t.lstrip("@")
+        data, f = await self.fetch_json(
+            f"{BSKY}/app.bsky.feed.getAuthorFeed?actor={actor}&limit={limit}&filter=posts_no_replies"
+        )
+        posts = [i["post"] for i in data.get("feed", [])]
+        items = [{"title": p.get("record", {}).get("text", "")[:120], "url": _bsky_url(p),
+                  "meta": [f"♥{p.get('likeCount', 0)}", f"↻{p.get('repostCount', 0)}",
+                           (p.get("record", {}).get("createdAt") or "")[:10]]} for p in posts]  # fmt: skip
+        return self.doc(
+            f,
+            f"https://bsky.app/profile/{actor}",
+            title=f"@{actor} on Bluesky",
+            body=listing(items),
+        )
+
+
+CHANNEL = FediverseChannel

agent_wire/channels/tier2_pro/hubs.py

@@ -0,0 +1,161 @@
+"""Package and model hubs: PyPI, npm, crates.io, Hugging Face (models + datasets)."""
+
+import asyncio
+from urllib.parse import quote, urlsplit
+
+from curl_cffi.requests.exceptions import RequestException
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import Channel, WireUnsupported, html_to_markdown
+from agent_wire.engine.waterfall import WireFetchError
+from agent_wire.models import WireSearchHit
+
+SEARCH_ERRORS = (WireFetchError, RequestException, ValueError, KeyError)
+
+
+def parse_pypi_search(html: str) -> list[WireSearchHit]:
+    hits = []
+    for a in LexborHTMLParser(html).css("a.package-snippet"):
+        name = a.css_first(".package-snippet__name")
+        desc = a.css_first(".package-snippet__description")
+        if name:
+            hits.append(WireSearchHit(url=f"https://pypi.org{a.attributes.get('href', '')}",
+                                      title=f"pypi: {name.text(strip=True)}",
+                                      snippet=desc.text(strip=True) if desc else "", source="pypi"))  # fmt: skip
+    return hits
+
+
+class HubsChannel(Channel):
+    name = "hubs"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        p = urlsplit(url)
+        host, segs = (p.hostname or "").removeprefix("www."), [s for s in p.path.split("/") if s]
+        if host == "pypi.org" and segs[:1] == ["project"] and len(segs) > 1:
+            return await self._pypi(url, segs[1], segs[2] if len(segs) > 2 else None)
+        if host.endswith("npmjs.com") and segs[:1] == ["package"] and len(segs) > 1:
+            name = "/".join(segs[1:3]) if segs[1].startswith("@") else segs[1]
+            return await self._npm(url, name)
+        if host == "crates.io" and segs[:1] == ["crates"] and len(segs) > 1:
+            return await self._crate(url, segs[1])
+        if host == "huggingface.co" and segs:
+            kind = (
+                "datasets"
+                if segs[0] == "datasets"
+                else "spaces"
+                if segs[0] == "spaces"
+                else "models"
+            )
+            repo = "/".join(segs[1:3] if kind != "models" else segs[:2])
+            return await self._hf(url, kind, repo)
+        return await self.ctx.channel("web").read(url, query=query, section=section)
+
+    async def _pypi(self, url, name, version):
+        path = f"{name}/{version}" if version else name
+        data, f = await self.fetch_json(f"https://pypi.org/pypi/{path}/json")
+        info = data.get("info", {})
+        urls = info.get("project_urls") or {}
+        meta = {"version": info.get("version"), "license": (info.get("license") or "")[:60] or None,
+                "requires_python": info.get("requires_python"),
+                "homepage": urls.get("Homepage") or urls.get("Source") or info.get("home_page")}  # fmt: skip
+        body = f"{info.get('summary') or ''}\n\n{info.get('description') or ''}".strip()
+        return self.doc(f, url, title=f"{info.get('name', name)} (PyPI)", author_handle=info.get("author"),
+                        body=body, metadata=meta)  # fmt: skip
+
+    async def _npm(self, url, name):
+        (data, f), downloads = await asyncio.gather(
+            self.fetch_json(f"https://registry.npmjs.org/{name.replace('/', '%2F')}"),
+            self._safe_json(f"https://api.npmjs.org/downloads/point/last-week/{name}"),
+        )
+        latest = (data.get("dist-tags") or {}).get("latest")
+        ver = (data.get("versions") or {}).get(latest, {})
+        repo = data.get("repository") or {}
+        meta = {"version": latest, "license": data.get("license") if isinstance(data.get("license"), str) else None,
+                "weekly_downloads": downloads.get("downloads"),
+                "repository": repo.get("url") if isinstance(repo, dict) else repo,
+                "modified": (data.get("time") or {}).get("modified", "")[:10] or None}  # fmt: skip
+        body = f"{data.get('description') or ver.get('description') or ''}\n\n{data.get('readme') or ''}".strip()
+        return self.doc(f, url, title=f"{name} (npm)", body=body, metadata=meta)
+
+    async def _crate(self, url, name):
+        data, f = await self.fetch_json(f"https://crates.io/api/v1/crates/{name}")
+        c = data.get("crate", {})
+        readme = ""
+        if ver := c.get("max_stable_version") or c.get("max_version"):
+            try:
+                rf = await self.fetch(f"https://crates.io/api/v1/crates/{name}/{ver}/readme",
+                                      archive=False, browser=False)  # fmt: skip
+                readme = html_to_markdown(rf.text)
+            except WireFetchError:
+                readme = ""
+        meta = {"version": ver, "downloads": c.get("downloads"), "recent_downloads": c.get("recent_downloads"),
+                "repository": c.get("repository")}  # fmt: skip
+        return self.doc(f, url, title=f"{name} (crates.io)", body=f"{c.get('description') or ''}\n\n{readme}".strip(),
+                        metadata=meta)  # fmt: skip
+
+    async def _hf(self, url, kind, repo):
+        api = f"https://huggingface.co/api/{kind}/{repo}"
+        raw = f"https://huggingface.co/{'' if kind == 'models' else kind + '/'}{repo}/raw/main/README.md"
+        (data, f), readme = await asyncio.gather(self.fetch_json(api), self._safe_text(raw))
+        meta = {"downloads": data.get("downloads"), "likes": data.get("likes"),
+                "pipeline": data.get("pipeline_tag"), "library": data.get("library_name"),
+                "license": next((t.split(":", 1)[1] for t in data.get("tags", []) if t.startswith("license:")), None),
+                "updated": (data.get("lastModified") or "")[:10] or None}  # fmt: skip
+        return self.doc(f, url, title=f"{repo} (Hugging Face {kind[:-1]})", author_handle=data.get("author"),
+                        body=readme, metadata=meta)  # fmt: skip
+
+    async def _safe_json(self, url) -> dict:
+        try:
+            return (await self.fetch_json(url))[0]
+        except SEARCH_ERRORS:
+            return {}
+
+    async def _safe_text(self, url) -> str:
+        try:
+            return (await self.fetch(url, archive=False, browser=False)).text
+        except SEARCH_ERRORS:
+            return ""
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        q = quote(query)
+
+        async def pypi():
+            f = await self.fetch(f"https://pypi.org/search/?q={q}", archive=False, browser=False)
+            return parse_pypi_search(f.text)
+
+        async def npm():
+            d, _ = await self.fetch_json(
+                f"https://registry.npmjs.org/-/v1/search?text={q}&size={limit}"
+            )
+            return [WireSearchHit(url=o["package"]["links"]["npm"], title=f"npm: {o['package']['name']}",
+                                  snippet=o["package"].get("description") or "", source="npm")
+                    for o in d.get("objects", [])]  # fmt: skip
+
+        async def crates():
+            d, _ = await self.fetch_json(f"https://crates.io/api/v1/crates?q={q}&per_page={limit}")
+            return [WireSearchHit(url=f"https://crates.io/crates/{c['name']}", title=f"crate: {c['name']}",
+                                  snippet=c.get("description") or "", source="crates")
+                    for c in d.get("crates", [])]  # fmt: skip
+
+        async def hf():
+            d, _ = await self.fetch_json(
+                f"https://huggingface.co/api/models?search={q}&limit={limit}&sort=downloads"
+            )
+            return [WireSearchHit(url=f"https://huggingface.co/{m['id']}", title=f"hf: {m['id']}",
+                                  snippet=f"{m.get('downloads', 0)} downloads · {m.get('pipeline_tag') or ''}",
+                                  source="huggingface") for m in d]  # fmt: skip
+
+        async def safe(fn):
+            try:
+                return (await fn())[:limit]
+            except SEARCH_ERRORS:
+                return []
+
+        lists = await asyncio.gather(*(safe(fn) for fn in (pypi, npm, crates, hf)))
+        hits = [h for group in lists for h in group]
+        if not hits:
+            raise WireUnsupported("no package/model hub returned results")
+        return hits
+
+
+CHANNEL = HubsChannel

agent_wire/channels/tier2_pro/linkedin.py

@@ -0,0 +1,146 @@
+"""LinkedIn: public guest job pages and search; posts/profiles via public JSON-LD or a local session."""
+
+import re
+from urllib.parse import parse_qs, quote, urlsplit
+
+from selectolax.lexbor import LexborHTMLParser
+
+from agent_wire.channels.base import (
+    Channel,
+    WireUnsupported,
+    html_to_markdown,
+    json_ld,
+    meta_tags,
+    ts,
+)
+from agent_wire.firewall.outbound_privacy import parse_json
+from agent_wire.models import WireComment, WireSearchHit
+
+GUEST = "https://www.linkedin.com/jobs-guest/jobs/api"
+
+
+def job_id(url: str) -> str | None:
+    p = urlsplit(url)
+    if m := re.search(r"/jobs/view/(?:[\w-]*?-)?(\d{6,})", p.path):
+        return m[1]
+    return parse_qs(p.query).get("currentJobId", [None])[0]
+
+
+def parse_job(html: str) -> dict:
+    tree = LexborHTMLParser(html)
+
+    def text(sel):
+        n = tree.css_first(sel)
+        return n.text(strip=True) if n else None
+
+    desc = tree.css_first(".show-more-less-html__markup, .description__text")
+    criteria = {
+        (li.css_first("h3").text(strip=True) if li.css_first("h3") else ""): (
+            li.css_first("span").text(strip=True) if li.css_first("span") else "")
+        for li in tree.css("li.description__job-criteria-item")
+    }  # fmt: skip
+    return {
+        "title": text("h2.top-card-layout__title, h1.top-card-layout__title, .topcard__title"),
+        "company": text("a.topcard__org-name-link, .topcard__flavor a"),
+        "location": text(".topcard__flavor--bullet"),
+        "body": html_to_markdown(desc.html) if desc else "",
+        "criteria": {k: v for k, v in criteria.items() if k},
+    }
+
+
+def parse_job_search(html: str) -> list[WireSearchHit]:
+    hits = []
+    for card in LexborHTMLParser(f"<ul>{html}</ul>").css("li"):
+        a = card.css_first("a.base-card__full-link, a[href*='/jobs/view/']")
+        title = card.css_first(".base-search-card__title")
+        if not a or not title:
+            continue
+        company = card.css_first(".base-search-card__subtitle")
+        loc = card.css_first(".job-search-card__location")
+        hits.append(WireSearchHit(
+            url=(a.attributes.get("href") or "").split("?")[0], title=title.text(strip=True),
+            snippet=" · ".join(n.text(strip=True) for n in (company, loc) if n), source="linkedin"))  # fmt: skip
+    return hits
+
+
+def parse_public_page(html: str) -> dict:
+    """Public post / profile / company pages: JSON-LD first, OpenGraph as fallback."""
+    for item in json_ld(html):
+        kind = item.get("@type")
+        if kind in ("SocialMediaPosting", "Article", "DiscussionForumPosting"):
+            author = item.get("author") or {}
+            author = author[0] if isinstance(author, list) and author else author
+            comments = [
+                WireComment(id=str(i), body=c.get("text") or "", author_handle=(c.get("author") or {}).get("name"),
+                            timestamp=ts(c.get("datePublished")))
+                for i, c in enumerate(item.get("comment") or []) if isinstance(c, dict)
+            ]  # fmt: skip
+            stats = {s.get("interactionType", "").split("/")[-1]: s.get("userInteractionCount")
+                     for s in item.get("interactionStatistic") or [] if isinstance(s, dict)}  # fmt: skip
+            return {"title": item.get("headline") or (item.get("articleBody") or "")[:80],
+                    "author_handle": author.get("name") if isinstance(author, dict) else None,
+                    "timestamp": ts(item.get("datePublished")), "body": item.get("articleBody") or "",
+                    "comments": comments, "metadata": {k: v for k, v in stats.items() if k}}  # fmt: skip
+        if kind in ("Person", "Organization", "ProfilePage"):
+            entity = item.get("mainEntity", item)
+            return {"title": entity.get("name"), "body": entity.get("description") or "",
+                    "metadata": {"followers": (entity.get("interactionStatistic") or {}).get("userInteractionCount")
+                                 if isinstance(entity.get("interactionStatistic"), dict) else None,
+                                 "location": (entity.get("address") or {}).get("addressLocality")
+                                 if isinstance(entity.get("address"), dict) else None}}  # fmt: skip
+    m = meta_tags(html)
+    if not m.get("og:title"):
+        raise WireUnsupported("linkedin returned a login wall; run `wire auth login linkedin.com`")
+    return {"title": m.get("og:title"), "body": m.get("og:description", "")}
+
+
+def parse_voyager_profile(data: dict) -> dict:
+    included = data.get("included", [])
+    profile = next((i for i in included if i.get("$type", "").endswith(".Profile")), {})
+    positions = [i for i in included if i.get("$type", "").endswith(".Position")]
+    schools = [i for i in included if i.get("$type", "").endswith(".Education")]
+    lines = [profile.get("headline") or "", profile.get("summary") or ""]
+    if positions:
+        lines.append(
+            "## Experience\n"
+            + "\n".join(f"- {p.get('title')} · {p.get('companyName')}" for p in positions)
+        )
+    if schools:
+        lines.append("## Education\n" + "\n".join(f"- {s.get('schoolName')}" for s in schools))
+    return {"title": f"{profile.get('firstName', '')} {profile.get('lastName', '')}".strip(),
+            "body": "\n\n".join(x for x in lines if x), "metadata": {"location": profile.get("locationName")}}  # fmt: skip
+
+
+class LinkedInChannel(Channel):
+    name = "linkedin"
+
+    async def read(self, url, *, query=None, section=None, include_comments=True):
+        if jid := job_id(url):
+            f = await self.fetch(f"{GUEST}/jobPosting/{jid}", archive=False)
+            job = parse_job(f.text)
+            if not job["title"]:
+                raise WireUnsupported(f"linkedin job {jid} not found or expired")
+            return self.doc(f, f"https://www.linkedin.com/jobs/view/{jid}", title=job["title"],
+                            author_handle=job["company"], body=job["body"],
+                            metadata={"location": job["location"], **job["criteria"]})  # fmt: skip
+        segs = [s for s in urlsplit(url).path.split("/") if s]
+        jar = await self.ctx.vault.cookies_for("linkedin.com") if self.ctx.vault else {}
+        if segs[:1] == ["in"] and len(segs) > 1 and jar.get("JSESSIONID"):
+            csrf = jar["JSESSIONID"].strip('"')
+            f = await self.fetch(
+                f"https://www.linkedin.com/voyager/api/identity/profiles/{segs[1]}/profileView",
+                headers={"csrf-token": csrf, "accept": "application/vnd.linkedin.normalized+json+2.1"},
+                archive=False, browser=False, cookies=jar,
+            )  # fmt: skip
+            return self.doc(f, url, **parse_voyager_profile(parse_json(f.content)))
+        f = await self.fetch(url, archive=False)
+        return self.doc(f, url, **parse_public_page(f.text))
+
+    async def search(self, query, *, limit=5, sort="relevance"):
+        f = await self.fetch(
+            f"{GUEST}/seeMoreJobPostings/search?keywords={quote(query)}&start=0", archive=False
+        )
+        return parse_job_search(f.text)[:limit]
+
+
+CHANNEL = LinkedInChannel