anyx 0.1.0__py3-none-any.whl

anyx/__init__.py

@@ -0,0 +1,14 @@
+"""anyx: use X from any browser, as any of your accounts. No API keys.
+
+    import anyx
+    with anyx.Session("alice") as x:
+        post = x.tweet("https://x.com/jack/status/20")
+        x.like(post["id"])
+        x.post("hello", quote=post["url"])
+"""
+
+from .errors import (ActionFailed, AnyxError, NotFound, RateLimited, SessionExpired, UIChanged,  # noqa: F401
+                     UsageError, WrongAccount)
+from .session import Session  # noqa: F401
+
+__version__ = "0.1.0"

anyx/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

anyx/accounts.py

@@ -0,0 +1,155 @@
+"""Getting accounts into the vault.
+
+    add       log in by hand once in a browser window anyx opens; anyx keeps the cookies
+    import    take cookies exported from any browser (JSON list or {name: value})
+    harvest   read every account logged into a browser (an AdsPower profile, a CDP browser, ...)
+              and store each one separately
+    check     open the account and see whether X still accepts it
+"""
+
+import time
+
+from . import browsers, config, vault
+from .errors import AnyxError, SessionExpired, UsageError
+
+
+def add(handle, timeout=600):
+    """Open a visible Chromium on X's login page and wait until `handle` is logged in."""
+    from playwright.sync_api import sync_playwright
+    handle = handle.lstrip("@").lower()
+    drv = browsers.get("chromium")
+    with sync_playwright() as pw:
+        ctx = drv.open(pw, handle, {"browser": "chromium"}, None, headless=False)
+        try:
+            p = ctx.pages[0] if ctx.pages else ctx.new_page()
+            p.goto("https://x.com/i/flow/login", wait_until="domcontentloaded")
+            end = time.monotonic() + timeout
+            who = None
+            while time.monotonic() < end:
+                link = p.locator('[data-testid="AppTabBar_Profile_Link"]')
+                if link.count():
+                    who = (link.get_attribute("href") or "").strip("/").lower()
+                    if who:
+                        break
+                p.wait_for_timeout(1500)
+            if not who:
+                raise AnyxError("gave up waiting for the login")
+            if who != handle:
+                raise AnyxError(f"logged in as @{who}, not @{handle}; nothing saved")
+            cookies = [c for c in ctx.cookies("https://x.com")]
+            vault.save(handle, cookies)
+            vault.set_born(handle, "chromium")
+            config.set_account(handle, browser="chromium")
+            return {"user": handle, "result": "saved"}
+        finally:
+            drv.close()
+            drv.stop(handle)          # the login window; the next command starts the account's own browser
+
+
+def import_file(handle, path, browser=None, profile=None):
+    """Cookies exported from a browser. Say which browser they came from (--browser, --profile): anyx
+    will use them only there."""
+    if not browser:
+        raise UsageError("say which browser these cookies were made in: --browser chromium|chrome|cdp|adspower "
+                         "[--profile <adspower profile>]; anyx uses them only there")
+    import json
+    with open(path, encoding="utf-8") as f:
+        data = json.load(f)
+    if isinstance(data, dict) and handle in data:
+        data = data[handle]
+    cookies = vault.normalize(data)
+    if not any(c["name"] == "auth_token" for c in cookies):
+        raise UsageError("no auth_token in that file")
+    vault.save(handle, cookies)
+    vault.set_born(handle, browser, profile)
+    config.set_account(handle, browser=browser, profile=profile)
+    return {"user": handle.lstrip("@").lower(), "result": "saved"}
+
+
+def harvest(browser, profile=None, cdp=None, set_browser=True):
+    """Store every account logged into one browser. With AdsPower each account is opened once to learn
+    its handle, then the browser is left as the first account it was."""
+    from playwright.sync_api import sync_playwright
+    acct = {"browser": browser, "profile": profile, "cdp": cdp, "_adspower": config.load().get("adspower", {})}
+    drv = browsers.get(browser)
+    out = {}
+    with sync_playwright() as pw:
+        ctx = drv.open(pw, "_harvest", acct, None, headless=True)
+        jar = drv.cookies()
+        drv.close()
+        sets = vault.split(jar)
+        if not sets:
+            raise AnyxError("no logged-in X account in that browser")
+        active = vault.user_id(vault.normalize(jar))
+        for uid, cookies in sets.items():
+            drv = browsers.get(browser)
+            ctx = drv.open(pw, "_harvest", acct, cookies, headless=True)
+            try:
+                p = ctx.pages[0] if ctx.pages else ctx.new_page()
+                p.set_viewport_size({"width": 1280, "height": 1000})   # narrower windows fold the side bar away
+                p.goto("https://x.com/home", wait_until="domcontentloaded")
+                link = p.locator('[data-testid="AppTabBar_Profile_Link"]')
+                try:
+                    link.wait_for(state="attached", timeout=40000)
+                    who = (link.get_attribute("href") or "").strip("/").lower()
+                except Exception:
+                    who = None
+            finally:
+                drv.close()
+            if not who:
+                out[uid] = None
+                continue
+            vault.save(who, cookies)
+            vault.set_born(who, browser, profile)
+            if set_browser:
+                config.set_account(who, browser=browser, profile=profile, cdp=cdp)
+            out[uid] = who
+        if browser == "adspower" and active in sets:
+            # leave the profile logged in as the account it showed before
+            drv = browsers.get(browser)
+            drv._setup(acct)
+            import json as _j
+            drv.call("/api/v1/user/update", method="POST", user_id=drv.profile_id(profile),
+                     cookie=_j.dumps(sets[active]))
+    return [{"user_id": u, "user": h} for u, h in out.items()]
+
+
+def check(handle):
+    """Is the account usable right now? Opens it once and reports what X shows:
+    ok, expired (logged out), locked (X wants a check), suspended, rate_limited, wrong_account."""
+    from .errors import NotFound, RateLimited, WrongAccount
+    from .session import Session
+    out = {"user": handle.lstrip("@").lower()}
+    try:
+        with Session(handle, verify="full") as x:
+            out["browser"] = x.account["browser"]
+            try:
+                u = x.user(x.me)
+                out.update(result="ok", followers=u["followers"], following=u["following"], posts=u["posts"],
+                           protected=u["protected"], verified=u["verified"])
+            except NotFound as e:
+                out.update(result="suspended" if "Suspended" in str(e) else "unavailable", detail=str(e))
+            if out.get("result") == "ok" and (u.get("posts") or 0) > 0:
+                try:
+                    hits = x.search(f"from:{x.me}", limit=3)
+                    out["in_search"] = len(hits) > 0
+                except Exception as e:  # noqa: BLE001
+                    out["in_search"] = None
+                    out["search_error"] = str(e)
+    except SessionExpired as e:
+        out.update(result="locked" if "locked" in str(e) else "expired", detail=str(e))
+    except RateLimited as e:
+        out.update(result="rate_limited", detail=str(e))
+    except WrongAccount as e:
+        out.update(result="wrong_account", detail=str(e))
+    return out
+
+
+def listing():
+    cfg = config.load()
+    rows = []
+    for h in sorted(set(vault.handles()) | set(cfg["accounts"])):
+        a = cfg["accounts"].get(h, {})
+        rows.append({"user": h, "browser": a.get("browser", cfg["default_browser"]),
+                     "profile": a.get("profile"), "cdp": a.get("cdp"), "cookies": vault.load(h) is not None})
+    return rows

anyx/act.py

@@ -0,0 +1,298 @@
+"""Acting on posts and accounts. Each action clicks what a person would click, then waits for X's
+own request (FavoriteTweet, friendships/create, ...) to come back before it reports success. If the
+state is already what was asked (liking a post that is liked), it returns "already" and clicks nothing.
+"""
+
+from . import graphql
+from .errors import ActionFailed, UIChanged
+
+# Menu entries X gives no data-testid. Matched by their text in the languages anyx knows.
+TEXT = {
+    "delete": ("削除", "Delete", "Eliminar", "Supprimer", "Löschen", "삭제", "删除"),
+}
+
+
+def _post_action(self, ref, button, confirm=None, wait=None, done_button=None):
+    from .session import tweet_id
+    tid = tweet_id(ref)
+    p = self.page()
+    cap = graphql.Capture(p)
+    try:
+        self.goto(p, f"https://x.com/i/status/{tid}")
+        art = self.article(p, tid)
+        if done_button and art.locator(f'[data-testid="{done_button}"]').count():
+            return {"id": tid, "result": "already"}
+        b = art.locator(f'[data-testid="{button}"]').first
+        if not b.count():
+            raise UIChanged(f'no [data-testid="{button}"] on post {tid}')
+        self.before_write()
+        n = len(cap.items)
+        b.click()
+        if confirm:
+            c = p.locator(f'[data-testid="{confirm}"]').first
+            c.wait_for(state="visible", timeout=15000)
+            c.click()
+        if wait:
+            b = cap.wait_for((wait,), timeout=20, after=n)
+            if b is None:
+                raise ActionFailed(f"X did not confirm {wait} for {tid}")
+            if cap.refusal(b):
+                raise ActionFailed(f"X refused {wait} for {tid}: {cap.refusal(b)}")
+        return {"id": tid, "result": "done"}
+    finally:
+        cap.detach()
+        p.close()
+
+
+def like(self, ref):
+    return _post_action(self, ref, "like", wait="FavoriteTweet", done_button="unlike")
+
+
+def unlike(self, ref):
+    return _post_action(self, ref, "unlike", wait="UnfavoriteTweet", done_button="like")
+
+
+def retweet(self, ref):
+    return _post_action(self, ref, "retweet", confirm="retweetConfirm", wait="CreateRetweet", done_button="unretweet")
+
+
+def unretweet(self, ref):
+    return _post_action(self, ref, "unretweet", confirm="unretweetConfirm", wait="DeleteRetweet", done_button="retweet")
+
+
+def bookmark(self, ref):
+    return _post_action(self, ref, "bookmark", wait="CreateBookmark", done_button="removeBookmark")
+
+
+def unbookmark(self, ref):
+    return _post_action(self, ref, "removeBookmark", wait="DeleteBookmark", done_button="bookmark")
+
+
+def _caret_menu(self, p, art):
+    for _ in range(3):
+        if p.locator('#layers [data-testid="mask"]').count() == 0:
+            break
+        p.keyboard.press("Escape")
+        p.wait_for_timeout(600)
+    art.locator('[data-testid="caret"]').first.click()
+    menu = p.locator('[role="menu"]').first
+    menu.wait_for(state="visible", timeout=15000)
+    return menu
+
+
+def delete(self, ref):
+    """Delete one of this account's own posts."""
+    from .session import tweet_id
+    tid = tweet_id(ref)
+    p = self.page()
+    cap = graphql.Capture(p)
+    try:
+        self.goto(p, f"https://x.com/i/status/{tid}")
+        art = self.article(p, tid)
+        menu = _caret_menu(self, p, art)
+        item = menu.locator('[role="menuitem"]').filter(has_text=TEXT["delete"][0])
+        for word in TEXT["delete"][1:]:
+            if item.count():
+                break
+            item = menu.locator('[role="menuitem"]').filter(has_text=word)
+        if not item.count():
+            p.keyboard.press("Escape")
+            raise UIChanged(f"no delete entry in the menu of {tid} (is it this account's post?)")
+        self.before_write()
+        n = len(cap.items)
+        item.first.click()
+        c = p.locator('[data-testid="confirmationSheetConfirm"]').first
+        c.wait_for(state="visible", timeout=15000)
+        c.click()
+        b = cap.wait_for(("DeleteTweet",), timeout=20, after=n)
+        if b is None:
+            raise ActionFailed(f"X did not confirm DeleteTweet for {tid}")
+        if cap.refusal(b):
+            raise ActionFailed(f"X refused to delete {tid}: {cap.refusal(b)}")
+        return {"id": tid, "result": "deleted"}
+    finally:
+        cap.detach()
+        p.close()
+
+
+def _pin(self, ref, testid, op):
+    from .session import tweet_id
+    tid = tweet_id(ref)
+    p = self.page()
+    cap = graphql.Capture(p)
+    try:
+        self.goto(p, f"https://x.com/i/status/{tid}")
+        art = self.article(p, tid)
+        menu = _caret_menu(self, p, art)
+        item = menu.locator(f'[data-testid="{testid}"]')
+        if not item.count():
+            p.keyboard.press("Escape")
+            other = "unpin" if testid == "pin" else "pin"
+            if menu.locator(f'[data-testid="{other}"]').count():
+                return {"id": tid, "result": "already"}
+            raise UIChanged(f'no [data-testid="{testid}"] in the menu of {tid}')
+        self.before_write()
+        n = len(cap.items)
+        item.first.click()
+        c = p.locator('[data-testid="confirmationSheetConfirm"]').first
+        try:
+            c.wait_for(state="visible", timeout=8000)
+            c.click()
+        except Exception:
+            pass
+        cap.confirm((op,), f"{op} for {tid}", after=n, timeout=20)
+        return {"id": tid, "result": "done"}
+    finally:
+        cap.detach()
+        p.close()
+
+
+def pin(self, ref):
+    return _pin(self, ref, "pin", "PinTweet")
+
+
+def unpin(self, ref):
+    return _pin(self, ref, "unpin", "UnpinTweet")
+
+
+def _profile(self, ref):
+    """Open a profile page and return (page, capture, user id)."""
+    from .session import handle_of
+    h = handle_of(ref)
+    p = self.page()
+    cap = graphql.Capture(p)
+    self.goto(p, f"https://x.com/{h}")
+    b = cap.wait_for(("UserByScreenName",), timeout=30)
+    _, us = graphql.walk([b] if b else [])
+    u = next((x for x in us if (x["handle"] or "").lower() == h.lower()), None)
+    if not u:
+        cap.detach()
+        p.close()
+        from .errors import NotFound
+        raise NotFound(f"@{h} not found")
+    p.locator('[data-testid="primaryColumn"]').wait_for(state="visible", timeout=20000)
+    p.wait_for_timeout(1500)
+    return p, cap, u
+
+
+def _account_action(self, ref, button, rest, confirm=False, state=None, want=True, menu=False, alt=None):
+    """Click an account-level button. `state` names the user flag (i_follow, i_mute, i_block) that tells
+    whether the change is already in place; X's own JSON says so, so no button text is read."""
+    p, cap, u = _profile(self, ref)
+    try:
+        if state and bool(u.get(state)) == want:
+            return {"user": u["handle"], "result": "already"}
+        col = p.locator('[data-testid="primaryColumn"]')
+        bt = button.format(id=u["id"])
+        target = None
+        if alt and col.locator(f'[data-testid="{alt}"]').count():
+            target = col.locator(f'[data-testid="{alt}"]')
+        elif menu:
+            col.locator('[data-testid="userActions"]').first.click()
+            m = p.locator('[role="menu"]').first
+            m.wait_for(state="visible", timeout=15000)
+            target = m.locator(f'[data-testid="{bt}"]')
+            if not target.count():
+                p.keyboard.press("Escape")
+                raise UIChanged(f'no [data-testid="{bt}"] in the profile menu of @{u["handle"]}')
+        else:
+            target = col.locator(f'[data-testid="{bt}"]')
+            if not target.count():
+                raise UIChanged(f'no [data-testid="{bt}"] on the profile of @{u["handle"]}')
+        self.before_write()
+        n = len(cap.rest)
+        target.first.click()
+        # Some of these ask "are you sure" and some do not, and X changes which. Confirm when asked.
+        c = p.locator('[data-testid="confirmationSheetConfirm"]').first
+        try:
+            c.wait_for(state="visible", timeout=15000 if confirm else 4000)
+            c.click()
+        except Exception:
+            if confirm:
+                raise UIChanged(f"no confirmation sheet after {bt} on @{u['handle']}")
+        b = cap.wait_rest(rest, timeout=20, after=n)
+        if b is None:
+            raise ActionFailed(f"X did not confirm {rest} for @{u['handle']}")
+        if cap.refusal(b):
+            raise ActionFailed(f"X refused {rest} for @{u['handle']}: {cap.refusal(b)}")
+        return {"user": u["handle"], "result": "done"}
+    finally:
+        cap.detach()
+        p.close()
+
+
+def follow(self, ref):
+    return _account_action(self, ref, "{id}-follow", "friendships/create", state="i_follow", want=True)
+
+
+def unfollow(self, ref):
+    return _account_action(self, ref, "{id}-unfollow", "friendships/destroy", confirm=True, state="i_follow", want=False)
+
+
+def mute(self, ref):
+    return _account_action(self, ref, "mute", "mutes/users/create", menu=True, state="i_mute", want=True)
+
+
+def unmute(self, ref):
+    # A muted profile shows an Unmute link in its header; the menu entry keeps the testid "mute".
+    return _account_action(self, ref, "mute", "mutes/users/destroy", menu=True, alt="unmuteLink",
+                           state="i_mute", want=False)
+
+
+def block(self, ref):
+    return _account_action(self, ref, "block", "blocks/create", confirm=True, menu=True, state="i_block", want=True)
+
+
+def unblock(self, ref):
+    return _account_action(self, ref, "{id}-unblock", "blocks/destroy", confirm=True, state="i_block", want=False)
+
+
+def edit_profile(self, name=None, bio=None, location=None, website=None, avatar=None, banner=None, drop_banner=False):
+    """Change this account's profile. Anything left as None is not touched. The handle is never changed."""
+    p = self.page()
+    cap = graphql.Capture(p)
+    try:
+        self.goto(p, "https://x.com/settings/profile")
+        nm = p.locator('input[name="displayName"]').first
+        nm.wait_for(state="visible", timeout=30000)
+        p.wait_for_timeout(1500)
+        for sel, val in (('input[name="displayName"]', name), ('textarea[name="description"]', bio),
+                         ('input[name="location"]', location), ('input[name="url"]', website)):
+            if val is not None:
+                f = p.locator(sel).first
+                if not f.count():
+                    raise UIChanged(f"no {sel} on the profile editor")
+                f.fill(val)
+        files = p.locator('input[type="file"]')
+        for idx, img in ((1, avatar), (0, banner)):
+            if img is None:
+                continue
+            if files.count() < 2:
+                raise UIChanged("the profile editor has no image inputs")
+            files.nth(idx).set_input_files(img)
+            p.locator('[data-testid="applyButton"]').first.click(timeout=20000)
+            p.wait_for_timeout(2000)
+        if drop_banner:
+            # The banner row shows a remove button only when a banner exists. It has no testid; its
+            # position is the second button in the banner area.
+            rm = p.locator('[aria-label="画像を削除"], [aria-label="Remove photo"]')
+            if rm.count():
+                rm.first.click()
+                p.wait_for_timeout(800)
+        self.before_write()
+        n = len(cap.rest)
+        p.locator('[data-testid="Profile_Save_Button"]').first.click(timeout=20000)
+        p.wait_for_timeout(1500)
+        ok = p.locator('[data-testid="confirmationSheetConfirm"]')
+        if ok.count():
+            ok.first.click(timeout=10000)
+        b = cap.wait_rest("account/update_profile", timeout=25, after=n)
+        if b is None:
+            raise ActionFailed("X did not confirm the profile update")
+        if cap.refusal(b):
+            raise ActionFailed(f"X refused the profile update: {cap.refusal(b)}")
+        p.wait_for_timeout(2000)
+        return {"user": self.me, "result": "done"}
+    finally:
+        cap.detach()
+        p.close()

anyx/browsers/__init__.py

@@ -0,0 +1,28 @@
+"""Browsers anyx can drive. Each one only has to open a Playwright BrowserContext with the given
+cookies poured in, and close it again. Everything X-specific lives above this layer.
+
+    chromium   Playwright's own Chromium with a profile under ~/.anyx/profiles/<handle>/. The default.
+    chrome     The Google Chrome installed on this machine, same profile layout.
+    cdp        A browser you already started with --remote-debugging-port. anyx attaches and leaves it open.
+    adspower   An AdsPower profile, started through AdsPower's Local API.
+
+Adding a browser is one class with open() and close().
+"""
+
+from ..errors import UsageError
+
+
+def get(name):
+    if name in ("chromium", "chrome"):
+        from .chromium import Chromium
+        return Chromium(channel="chrome" if name == "chrome" else None)
+    if name == "cdp":
+        from .cdp import CDP
+        return CDP()
+    if name == "adspower":
+        from .adspower import AdsPower
+        return AdsPower()
+    raise UsageError(f"unknown browser: {name} (chromium, chrome, cdp, adspower)")
+
+
+NAMES = ("chromium", "chrome", "cdp", "adspower")

anyx/browsers/adspower.py

@@ -0,0 +1,136 @@
+"""AdsPower, through its Local API.
+
+The API key comes from `adspower.key` in config (`anyx config set adspower.key KEY`), or else from
+the environment variable named by `adspower.key_env` (default ADSPOWER_API_KEY). Calls are serialized per machine with a lock file and
+spaced at least 1.1 s apart, which is what AdsPower tolerates.
+"""
+
+import fcntl
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+from contextlib import contextmanager
+
+from ..errors import AnyxError, UsageError
+
+LOCK = "/tmp/adspower-api.lock"
+GAP = 1.1
+DEFAULT_API = "http://local.adspower.net:50325"
+
+
+@contextmanager
+def _gate():
+    with open(LOCK, "a") as f:
+        deadline = time.monotonic() + 150
+        while True:
+            try:
+                fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                break
+            except BlockingIOError:
+                if time.monotonic() > deadline:
+                    raise AnyxError("AdsPower API is busy (another process holds the lock)")
+                time.sleep(0.2)
+        try:
+            age = time.time() - os.path.getmtime(LOCK)
+            if age < GAP:
+                time.sleep(GAP - age)
+            yield
+        finally:
+            os.utime(LOCK, None)
+            fcntl.flock(f, fcntl.LOCK_UN)
+
+
+class AdsPower:
+    def __init__(self):
+        self.uid = None
+        self.ctx = None
+        self.fresh = False
+        self.api = DEFAULT_API
+        self.key = None
+
+    def call(self, path, method="GET", **q):
+        url = self.api + path
+        data = None
+        headers = {"Authorization": "Bearer " + (self.key or "")}
+        if method == "POST":
+            data = json.dumps(q).encode()
+            headers["Content-Type"] = "application/json"
+        elif q:
+            url += "?" + urllib.parse.urlencode(q)
+        with _gate():
+            with urllib.request.urlopen(urllib.request.Request(url, data=data, headers=headers), timeout=120) as r:
+                return json.load(r)
+
+    def _setup(self, account):
+        ap = account.get("_adspower") or {}
+        self.api = ap.get("api") or os.environ.get("ADSPOWER_API") or DEFAULT_API
+        self.key = ap.get("key") or os.environ.get(ap.get("key_env") or "ADSPOWER_API_KEY")
+        if not self.key:
+            raise UsageError("AdsPower API key missing: anyx config set adspower.key <key> (or set ADSPOWER_API_KEY)")
+
+    def profile_id(self, name):
+        page = 1
+        while True:
+            users = self.call("/api/v1/user/list", page=page, page_size=100)["data"]["list"]
+            for u in users:
+                if u["name"] == name or u["user_id"] == name:
+                    return u["user_id"]
+            if len(users) < 100:
+                break
+            page += 1
+        raise UsageError(f"no AdsPower profile named {name}")
+
+    def open(self, pw, handle, account, cookies, headless=True):
+        """Attach to the profile if it is already open (left open by an earlier command, or by hand);
+        start it otherwise. It is left open afterwards."""
+        from .. import run
+        self._setup(account)
+        if not account.get("profile"):
+            raise UsageError(f"@{handle} uses adspower but has no profile "
+                             f"(anyx accounts set {handle} --browser adspower --profile <name>)")
+        last = run.load(handle).get("browser") or {}
+        self.uid = last.get("user_id") if last.get("profile") == account["profile"] else None
+        self.uid = self.uid or self.profile_id(account["profile"])
+        st = self.call("/api/v1/browser/active", user_id=self.uid)
+        ws = ((st.get("data") or {}).get("ws") or {}).get("puppeteer") if (st.get("data") or {}).get("status") == "Active" else None
+        if not ws:
+            if cookies:
+                r = self.call("/api/v1/user/update", method="POST", user_id=self.uid, cookie=json.dumps(cookies))
+                if r.get("code") != 0:
+                    raise AnyxError(f"AdsPower refused the cookies: {r.get('msg')}")
+                time.sleep(1.5)
+            r = self.call("/api/v1/browser/start", user_id=self.uid, headless="1" if headless else "0", open_tabs=1)
+            if r.get("code") != 0:
+                raise AnyxError(f"AdsPower could not start {account['profile']}: {r.get('msg')}")
+            ws = r["data"]["ws"]["puppeteer"]
+            self.fresh = True
+        browser = pw.chromium.connect_over_cdp(ws)
+        self.ctx = browser.contexts[0]
+        if cookies:
+            have = {c["name"]: c["value"] for c in self.ctx.cookies("https://x.com")}
+            if have.get("auth_token") != {c["name"]: c["value"] for c in cookies}.get("auth_token"):
+                self.ctx.clear_cookies(domain=".x.com")
+                self.ctx.add_cookies(cookies)
+                self.fresh = True
+        run.save(handle, browser={"kind": "adspower", "profile": account["profile"], "user_id": self.uid})
+        return self.ctx
+
+    def close(self):
+        # the profile stays open for the next command; `anyx stop` closes it
+        self.ctx = None
+
+    def cookies(self):
+        return self.ctx.cookies("https://x.com") if self.ctx else []
+
+    @staticmethod
+    def stop(handle):
+        from .. import config, run
+        info = run.load(handle).get("browser") or {}
+        if info.get("user_id"):
+            a = AdsPower()
+            a._setup(config.account(handle))
+            a.call("/api/v1/browser/stop", user_id=info["user_id"])
+        run.forget(handle, "browser")
+        return bool(info)