assertify-mcp 0.6.3__py3-none-any.whl

assertify/cli.py

@@ -0,0 +1,120 @@
+"""Command line: `assertify serve | login | list | delete`."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+import threading
+
+from .vault import Vault, VaultError
+
+
+async def _login(profile: str | None, url: str, domains: list[str], read_only: bool) -> None:
+    from .browser import BrowserManager
+
+    m = BrowserManager()
+    try:
+        await m.start_login(profile, url, domains, read_only=read_only)
+        profile = next(iter(m.logins))
+        print(f"A browser window is open at {url}. Log in there (including any 2FA).")
+        print("When you're done, close the browser window or press Enter here.")
+        closed = asyncio.create_task(m.logins[profile].done.wait())
+        enter = asyncio.create_task(_wait_for_enter())
+        await asyncio.wait({closed, enter}, return_when=asyncio.FIRST_COMPLETED)
+        enter.cancel()
+        print(await m.wait_login(profile) if closed.done() else await m.complete_login(profile))
+    finally:
+        await m.shutdown()
+
+
+async def _wait_for_enter() -> None:
+    """Wait for Enter while still letting a closed window end the command."""
+    loop = asyncio.get_running_loop()
+    fut = loop.create_future()
+
+    def done() -> None:
+        if not fut.done():
+            fut.set_result(None)
+
+    try:
+        loop.add_reader(sys.stdin, lambda: (sys.stdin.readline(), done()))
+    except (NotImplementedError, ValueError, OSError):
+        # Windows has no add_reader: read in a daemon thread, which can't keep the process alive.
+        def read() -> None:
+            try:
+                sys.stdin.readline()
+            except Exception:
+                return
+            loop.call_soon_threadsafe(done)
+
+        threading.Thread(target=read, daemon=True).start()
+        return await fut
+    try:
+        await fut
+    finally:
+        loop.remove_reader(sys.stdin)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="assertify")
+    sub = p.add_subparsers(dest="cmd")
+    sub.add_parser("setup", help="One-time setup: install the browser, check encryption, show how to connect")
+    sub.add_parser("serve", help="Run the MCP server over stdio (default)")
+    lg = sub.add_parser("login", help="Log in to a site in a visible browser and save the session")
+    lg.add_argument("args", nargs="+", metavar="[name] url", help="Name is optional: defaults to the account's email")
+    lg.add_argument("--domain", action="append", default=[], help="Allowed domain (repeatable)")
+    lg.add_argument(
+        "--read-only", action="store_true", help="Agents may browse and read, but never type, submit, send or buy"
+    )
+    ls = sub.add_parser("list", help="List saved sessions")
+    ls.add_argument("site", nargs="?", help="Only this site's logins")
+    rn = sub.add_parser("rename", help="Rename a saved session")
+    rn.add_argument("profile")
+    rn.add_argument("new_name")
+    dl = sub.add_parser("delete", help="Delete a saved session")
+    dl.add_argument("profile")
+    rl = sub.add_parser("relay", help="Serve the Assertify phone app to remote agents (Claude mobile, Codex)")
+    rl.add_argument("--host", default="127.0.0.1", help="Address to listen on (0.0.0.0 for your LAN)")
+    rl.add_argument("--port", type=int, default=8765)
+    rl.add_argument("--public-url", help="The https:// address agents reach this relay at (e.g. a tunnel)")
+    rl.add_argument("--new-token", action="store_true", help="Make a new secret (unpairs the phone)")
+    args = p.parse_args()
+    if args.cmd not in (None, "serve"):
+        # Windows consoles may not be UTF-8; never crash on a ✓ or an emoji in a page title.
+        for stream in (sys.stdout, sys.stderr):
+            if hasattr(stream, "reconfigure"):
+                stream.reconfigure(errors="replace")
+
+    try:
+        if args.cmd in (None, "serve"):
+            from .server import run
+
+            run()
+        elif args.cmd == "setup":
+            from .install import setup
+
+            sys.exit(setup())
+        elif args.cmd == "login":
+            if len(args.args) > 2:
+                p.error("login takes [name] url")
+            name, url = (None, args.args[0]) if len(args.args) == 1 else args.args
+            asyncio.run(_login(name, url, args.domain, args.read_only))
+        elif args.cmd == "list":
+            print(json.dumps(Vault().list(args.site), indent=2, default=str))
+        elif args.cmd == "rename":
+            Vault().rename(args.profile, args.new_name)
+            print(f"Renamed to {args.new_name!r}.")
+        elif args.cmd == "relay":
+            from .relay import serve
+
+            serve(args.host, args.port, args.public_url, args.new_token)
+        elif args.cmd == "delete":
+            print("Deleted." if Vault().delete(args.profile) else "No such profile.")
+    except VaultError as e:
+        sys.exit(f"error: {e}")
+
+
+if __name__ == "__main__":
+    main()

assertify/files.py

@@ -0,0 +1,177 @@
+"""Turn a downloaded file into text the agent can read: CSV/TSV as a table, Excel's first sheets,
+PDF text, and plain text formats. Files come from websites, so this only ever reads them."""
+
+from __future__ import annotations
+
+import csv
+import io
+import re
+import zipfile
+from pathlib import Path
+from xml.etree import ElementTree
+
+TEXT_TYPES = {
+    ".txt",
+    ".log",
+    ".md",
+    ".json",
+    ".xml",
+    ".html",
+    ".htm",
+    ".ics",
+    ".vcf",
+    ".yaml",
+    ".yml",
+    ".srt",
+    ".vtt",
+}
+MAX_UNZIPPED = 50 * 1024 * 1024  # an .xlsx that unpacks bigger than this isn't read
+
+
+def safe_name(name: str) -> str:
+    name = Path(name.replace("\\", "/")).name
+    name = re.sub(r"[^\w.\- ()\[\]]+", "_", name).strip(". ")[:120]
+    return name or "download"
+
+
+def decode(data: bytes) -> str:
+    for enc in ("utf-16", "utf-8-sig") if data[:2] in (b"\xff\xfe", b"\xfe\xff") else ("utf-8-sig",):
+        try:
+            return data.decode(enc)
+        except UnicodeDecodeError:
+            pass
+    return data.decode("cp1252", errors="replace")
+
+
+def table(rows: list[list[str]], max_rows: int = 200) -> str:
+    """Rows -> a Markdown table (first row is the header)."""
+    rows = [r for r in rows if any(c.strip() for c in r)]
+    if not rows:
+        return "(empty)"
+    width = max(len(r) for r in rows)
+
+    def cell(c: str) -> str:
+        c = " ".join(c.split()).replace("|", "\\|")
+        return c[:80] + "…" if len(c) > 80 else c
+
+    lines = []
+    for i, r in enumerate(rows[: max_rows + 1]):
+        lines.append("| " + " | ".join(cell(c) for c in r + [""] * (width - len(r))) + " |")
+        if i == 0:
+            lines.append("|" + " --- |" * width)
+    if len(rows) > max_rows + 1:
+        lines.append(f"(+{len(rows) - max_rows - 1} more rows; the full file is saved)")
+    return "\n".join(lines)
+
+
+def _csv(text: str, delimiter: str | None) -> str:
+    if delimiter is None:
+        try:
+            delimiter = csv.Sniffer().sniff(text[:5000], delimiters=",;\t|").delimiter
+        except csv.Error:
+            delimiter = ","
+    return table(list(csv.reader(io.StringIO(text), delimiter=delimiter)))
+
+
+def _xlsx(data: bytes) -> str:
+    ns = {"m": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
+    rel = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id"
+    with zipfile.ZipFile(io.BytesIO(data)) as z:
+        if sum(i.file_size for i in z.infolist()) > MAX_UNZIPPED:
+            return "(spreadsheet too big to read; the full file is saved)"
+
+        def xml(name: str):
+            return ElementTree.fromstring(z.read(name)) if name in z.namelist() else None
+
+        shared = []
+        sst = xml("xl/sharedStrings.xml")
+        if sst is not None:
+            shared = ["".join(t.text or "" for t in si.iter(f"{{{ns['m']}}}t")) for si in sst.findall("m:si", ns)]
+        book, rels = xml("xl/workbook.xml"), xml("xl/_rels/workbook.xml.rels")
+        targets = {r.get("Id"): r.get("Target") for r in rels} if rels is not None else {}
+        sheets = []
+        for sh in book.findall("m:sheets/m:sheet", ns) if book is not None else []:
+            target = targets.get(sh.get(rel), "")
+            target = target.lstrip("/") if target.startswith("/") else "xl/" + target
+            sheets.append((sh.get("name"), target))
+        out = []
+        for name, path in sheets[:5]:
+            root = xml(path)
+            if root is None:
+                continue
+            rows = []
+            for row in root.iter(f"{{{ns['m']}}}row"):
+                cells: dict[int, str] = {}
+                for c in row.findall("m:c", ns):
+                    col = _col(c.get("r", ""))
+                    v = c.find("m:v", ns)
+                    kind = c.get("t")
+                    if kind == "s" and v is not None:
+                        val = shared[int(v.text)] if v.text and v.text.isdigit() and int(v.text) < len(shared) else ""
+                    elif kind == "inlineStr":
+                        val = "".join(t.text or "" for t in c.iter(f"{{{ns['m']}}}t"))
+                    else:
+                        val = v.text if v is not None and v.text else ""
+                    cells[col if col >= 0 else len(cells)] = val
+                if cells:
+                    rows.append([cells.get(i, "") for i in range(max(cells) + 1)])
+            out.append(f"### Sheet: {name}\n{table(rows)}")
+        if len(sheets) > 5:
+            out.append(f"(+{len(sheets) - 5} more sheets)")
+        return "\n\n".join(out) or "(no sheets found)"
+
+
+def _col(ref: str) -> int:
+    n = 0
+    for ch in re.match(r"[A-Z]*", ref).group():
+        n = n * 26 + ord(ch) - 64
+    return n - 1
+
+
+def _pdf(path: Path) -> str:
+    try:
+        from pypdf import PdfReader
+    except ImportError:
+        return "(PDF saved; text extraction isn't available here)"
+    reader = PdfReader(str(path))
+    if reader.is_encrypted:
+        try:
+            reader.decrypt("")
+        except Exception:
+            return "(the PDF is password-protected)"
+    parts = []
+    for i, page in enumerate(reader.pages[:100]):
+        text = (page.extract_text() or "").strip()
+        if text:
+            parts.append(f"--- page {i + 1} ---\n{text}")
+    if len(reader.pages) > 100:
+        parts.append(f"(+{len(reader.pages) - 100} more pages)")
+    return "\n\n".join(parts) or "(no text in this PDF; it may be scanned images)"
+
+
+def _html(text: str) -> str:
+    text = re.sub(r"(?is)<(script|style)\b.*?</\1>", " ", text)
+    text = re.sub(r"(?i)<br\s*/?>|</(p|div|tr|li|h\d)>", "\n", text)
+    text = re.sub(r"<[^>]+>", " ", text)
+    return re.sub(r"[ \t]+", " ", text).strip()
+
+
+def read(path: Path, content_type: str = "") -> str | None:
+    """Readable text for a file, or None for kinds it can't read (images, archives, ...)."""
+    ext = path.suffix.lower()
+    ctype = content_type.split(";")[0].strip().lower()
+    data = path.read_bytes()
+    if ext == ".pdf" or ctype == "application/pdf" or data[:5] == b"%PDF-":
+        return _pdf(path)
+    if ext in (".xlsx", ".xlsm") or "spreadsheetml" in ctype:
+        try:
+            return _xlsx(data)
+        except (zipfile.BadZipFile, ElementTree.ParseError, KeyError):
+            return None
+    if ext in (".csv", ".tsv") or ctype in ("text/csv", "text/tab-separated-values"):
+        return _csv(decode(data), "\t" if ext == ".tsv" else None)
+    if ext in (".html", ".htm") or ctype == "text/html":
+        return _html(decode(data))
+    if ext in TEXT_TYPES or ctype.startswith("text/") or ctype in ("application/json", "application/xml"):
+        return decode(data)
+    return None

assertify/human.py

@@ -0,0 +1,95 @@
+"""Human-like pacing: random pauses, curved mouse paths, uneven typing.
+
+Bot detectors look for instant, pixel-perfect, perfectly regular input. This module makes
+actions look like a person's. Turn it off with ASSERTIFY_HUMANIZE=0 (tests, trusted sites).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import math
+import os
+import random
+
+from playwright.async_api import Page
+
+
+def enabled() -> bool:
+    return os.environ.get("ASSERTIFY_HUMANIZE", "1") != "0"
+
+
+async def pause(lo: float = 0.4, hi: float = 1.3, slow: float = 1.0) -> None:
+    """Think time between actions. `slow` > 1 for sites that are strict about automation."""
+    if enabled():
+        await asyncio.sleep(random.uniform(lo, hi) * slow)
+
+
+def point_in(box: dict) -> tuple[float, float]:
+    """A random point near the middle of an element, never the exact center."""
+    if not enabled():
+        return box["x"] + box["width"] / 2, box["y"] + box["height"] / 2
+    return (
+        box["x"] + box["width"] * random.uniform(0.3, 0.7),
+        box["y"] + box["height"] * random.uniform(0.3, 0.7),
+    )
+
+
+def _path(x0: float, y0: float, x1: float, y1: float) -> list[tuple[float, float]]:
+    """Eased curve from (x0, y0) to (x1, y1) with a random bend."""
+    dist = math.hypot(x1 - x0, y1 - y0)
+    steps = max(8, min(40, int(dist / 25)))
+    bend = min(dist * 0.25, 120)
+    cx = (x0 + x1) / 2 + random.uniform(-bend, bend)
+    cy = (y0 + y1) / 2 + random.uniform(-bend, bend)
+    pts = []
+    for i in range(1, steps + 1):
+        t = i / steps
+        t = t * t * (3 - 2 * t)  # ease in and out
+        pts.append(
+            (
+                (1 - t) ** 2 * x0 + 2 * (1 - t) * t * cx + t * t * x1,
+                (1 - t) ** 2 * y0 + 2 * (1 - t) * t * cy + t * t * y1,
+            )
+        )
+    return pts
+
+
+async def click_at(page: Page, start: tuple[float, float], x: float, y: float) -> None:
+    """Move the mouse along a curve, hover briefly, then press and release."""
+    if not enabled():
+        await page.mouse.click(x, y)
+        return
+    for px, py in _path(*start, x, y):
+        await page.mouse.move(px, py)
+        await asyncio.sleep(random.uniform(0.004, 0.016))
+    await asyncio.sleep(random.uniform(0.05, 0.25))
+    await page.mouse.down()
+    await asyncio.sleep(random.uniform(0.04, 0.12))
+    await page.mouse.up()
+
+
+async def type_text(page: Page, text: str) -> None:
+    """Type one key at a time with uneven gaps and the odd pause between words."""
+    if not enabled():
+        await page.keyboard.insert_text(text)
+        return
+    fast = len(text) > 200  # long text: still keystrokes, just quicker
+    for ch in text:
+        await page.keyboard.type(ch)
+        delay = random.uniform(0.035, 0.14)
+        if ch == " " and random.random() < 0.15:
+            delay += random.uniform(0.1, 0.4)
+        await asyncio.sleep(delay / 4 if fast else delay)
+
+
+async def wheel(page: Page, dy: float) -> None:
+    """Scroll in a few uneven flicks instead of one jump."""
+    if not enabled():
+        await page.mouse.wheel(0, dy)
+        return
+    left = dy
+    while abs(left) > 1:
+        step = math.copysign(min(abs(left), random.uniform(90, 260)), left)
+        await page.mouse.wheel(0, step)
+        left -= step
+        await asyncio.sleep(random.uniform(0.03, 0.12))

assertify/install.py

@@ -0,0 +1,107 @@
+"""Browser install + `assertify setup`.
+
+Python packages can't run code at install time, so the browser download happens either in
+`assertify setup` (recommended, right after installing) or automatically on first use.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+from playwright.async_api import Playwright
+
+# Real Chrome first: it looks like a normal browser to sites. Then full Chromium, whose "new" headless
+# mode is far harder to detect than the default headless shell.
+AUTO_CHANNELS = ["chrome", "chromium"]
+# Playwright adds --enable-automation, which shows the "controlled by automated software" bar and
+# sets navigator.webdriver. Drop it.
+STEALTH = {"ignore_default_args": ["--enable-automation"]}
+
+
+def install_chromium(out=None) -> bool:
+    """Download Playwright's Chromium (about 300 MB, once). Output goes to `out` (stderr by default,
+    because stdout is the MCP protocol channel when running as a server)."""
+    out = out or sys.stderr
+    print("assertify: downloading Chromium (one time, about 300 MB)...", file=out, flush=True)
+    cmd = [sys.executable, "-m", "playwright", "install", "chromium"]
+    result = subprocess.run(cmd, stdout=out, stderr=out)
+    return result.returncode == 0
+
+
+async def launch(pw: Playwright, **kwargs):
+    """Launch a browser. ASSERTIFY_BROWSER=chrome|chromium|msedge picks one; by default the user's
+    Chrome, else Chromium (installed on first use if needed), else Edge."""
+    kwargs = {**STEALTH, **kwargs}
+    choice = os.environ.get("ASSERTIFY_BROWSER", "").lower()
+    channels = [choice] if choice else AUTO_CHANNELS
+    errors = []
+    for channel in channels:
+        try:
+            return await pw.chromium.launch(channel=channel, **kwargs)
+        except Exception as e:
+            errors.append(f"{channel}: {str(e).splitlines()[0]}")
+    if "chromium" in channels and os.environ.get("ASSERTIFY_NO_AUTO_INSTALL") != "1":
+        if await asyncio.to_thread(install_chromium):
+            return await pw.chromium.launch(channel="chromium", **kwargs)
+    if not choice:
+        try:
+            return await pw.chromium.launch(channel="msedge", **kwargs)
+        except Exception as e:
+            errors.append(f"msedge: {str(e).splitlines()[0]}")
+    raise RuntimeError(
+        "No browser available (" + "; ".join(errors) + "). Run `assertify setup` in a terminal to fix this."
+    )
+
+
+def _mcp_command() -> list[str]:
+    """Absolute command that runs this exact install, wherever it lives."""
+    return [sys.executable, "-m", "assertify.cli", "serve"]
+
+
+def setup() -> int:
+    from playwright.sync_api import sync_playwright
+
+    from .vault import Vault, VaultError, vault_home
+
+    ok = True
+    print("assertify setup\n")
+
+    # 1. Browser
+    with sync_playwright() as pw:
+        have = Path(pw.chromium.executable_path).exists()
+    if have:
+        print("✓ Chromium is installed")
+    else:
+        print("… Chromium not found, installing it now")
+        if install_chromium(out=sys.stdout):
+            print("✓ Chromium installed")
+        else:
+            ok = False
+            print("✗ Chromium download failed. Check your connection and run `assertify setup` again.")
+            print("  (assertify will still use Google Chrome or Microsoft Edge if one is installed.)")
+    if platform.system() == "Linux":
+        print("  Linux: if the browser fails to start, install its system libraries with:")
+        print(f"    sudo {sys.executable} -m playwright install-deps chromium")
+
+    # 2. Encryption key
+    try:
+        _ = Vault().key
+        source = "ASSERTIFY_PASSPHRASE" if os.environ.get("ASSERTIFY_PASSPHRASE") else "OS keychain"
+        print(f"✓ Encryption key ready ({source}); vault at {vault_home()}")
+    except VaultError as e:
+        ok = False
+        print(f"✗ {e}")
+
+    # 3. How to connect it
+    cmd = " ".join(f'"{c}"' if " " in c else c for c in _mcp_command())
+    print("\nConnect it to your AI client:")
+    print(f"  Claude Code:  claude mcp add -s user assertify -- {cmd}")
+    args = ", ".join(f'"{c}"' for c in _mcp_command()[1:])
+    print(f'  JSON config:  "assertify": {{"command": "{sys.executable}", "args": [{args}]}}')
+    print("\nThen save a login, e.g.:  assertify login github https://github.com/login")
+    return 0 if ok else 1