webget-cli 0.6.0__tar.gz → 0.7.1__tar.gz

{webget_cli-0.6.0 → webget_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webget-cli
-Version: 0.6.0
+Version: 0.7.1
 Summary: Local search + scrape CLI with an HTTP fast path, optional browser fallback, and authenticated session profiles. Zero API keys.
 Author-email: David Tarigan <tarigansdavid@gmail.com>
 License: MIT
@@ -25,6 +25,8 @@ Requires-Dist: trafilatura
 Requires-Dist: html2text
 Provides-Extra: browser
 Requires-Dist: crawl4ai>=0.9; extra == "browser"
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2; extra == "mcp"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.6; extra == "dev"
@@ -210,6 +212,37 @@ fetches never collide. Failures are never cached.
 > **Privacy note:** cached content is plaintext JSON on disk. If you fetch
 > authenticated/personal pages, use `--no-cache`.
 
+## MCP server
+
+`webget_mcp.py` exposes the same ladder as an MCP server (`search`,
+`fetch`, `search_fetch`), so agents like opencode can search and scrape
+without API keys:
+
+```bash
+pip install "webget-cli[mcp]"
+```
+
+Register as a local MCP server in opencode:
+
+```jsonc
+{
+  "mcp": {
+    "webget": {
+      "type": "local",
+      "command": ["webget-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+Then prompt with `use webget` for search and scrape tasks. Run the server
+standalone with `webget-mcp` (stdio transport) or `python webget_mcp.py`.
+
+> **Limitation:** MCP tools do not expose `--profile`/`--cookies`, so
+> authenticated pages are out of scope for the MCP server. Use the CLI
+> (`webget login`, `webget u --profile ...`) for session-based fetching.
+
 ## Development
 
 ```bash

{webget_cli-0.6.0 → webget_cli-0.7.1}/README.md

@@ -178,6 +178,37 @@ fetches never collide. Failures are never cached.
 > **Privacy note:** cached content is plaintext JSON on disk. If you fetch
 > authenticated/personal pages, use `--no-cache`.
 
+## MCP server
+
+`webget_mcp.py` exposes the same ladder as an MCP server (`search`,
+`fetch`, `search_fetch`), so agents like opencode can search and scrape
+without API keys:
+
+```bash
+pip install "webget-cli[mcp]"
+```
+
+Register as a local MCP server in opencode:
+
+```jsonc
+{
+  "mcp": {
+    "webget": {
+      "type": "local",
+      "command": ["webget-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+Then prompt with `use webget` for search and scrape tasks. Run the server
+standalone with `webget-mcp` (stdio transport) or `python webget_mcp.py`.
+
+> **Limitation:** MCP tools do not expose `--profile`/`--cookies`, so
+> authenticated pages are out of scope for the MCP server. Use the CLI
+> (`webget login`, `webget u --profile ...`) for session-based fetching.
+
 ## Development
 
 ```bash

{webget_cli-0.6.0 → webget_cli-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webget-cli"
-version = "0.6.0"
+version = "0.7.1"
 description = "Local search + scrape CLI with an HTTP fast path, optional browser fallback, and authenticated session profiles. Zero API keys."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -35,13 +35,15 @@ Changelog = "https://github.com/DavidPandleton/webget/blob/main/CHANGELOG.md"
 
 [project.optional-dependencies]
 browser = ["crawl4ai>=0.9"]
+mcp = ["fastmcp>=2"]
 dev = ["pytest>=8", "ruff>=0.6"]
 
 [project.scripts]
 webget = "webget_cli:main"
+webget-mcp = "webget_mcp:main"
 
 [tool.setuptools]
-py-modules = ["webget_cli"]
+py-modules = ["webget_cli", "webget_mcp"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

webget_cli-0.7.1/tests/test_adversarial_auth.py

@@ -0,0 +1,145 @@
+"""Adversarial auth + cookie isolation tests: profiles, storage state,
+logout domain scoping, session reuse, corrupted state."""
+
+import asyncio
+import json
+import os
+
+import pytest
+
+import webget_cli as webget
+
+
+async def _fetch(url, **kw):
+    return await webget.scrape_many([url], max_chars=2000, no_cache=True, **kw)
+
+
+def _one(res):
+    return res[next(iter(res))]
+
+
+def _cookie(name, domain, expires=-1):
+    return {
+        "name": name,
+        "value": "v",
+        "domain": domain,
+        "path": "/",
+        "secure": False,
+        "expires": expires,
+    }
+
+
+class TestProfileSafety:
+    def test_profile_dir_rejects_traversal(self):
+        for name in ("../../etc", "..", ".", "a/b", "a\\b", "~evil", "", "/abs"):
+            with pytest.raises(SystemExit):
+                webget.profile_dir(name)
+
+
+class TestStorageState:
+    def test_load_profile_cookies_missing_file(self, isolated_env):
+        assert webget.load_profile_cookies("ghost") is None
+
+    def test_load_profile_cookies_corrupt(self, isolated_env):
+        p = webget.profile_state_path("campus")
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            f.write("{not json")
+        assert webget.load_profile_cookies("campus") is None
+
+    def test_load_profile_cookies_ok(self, isolated_env):
+        p = webget.profile_state_path("campus")
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            json.dump({"cookies": [_cookie("s", ".campus.example")]}, f)
+        ck = webget.load_profile_cookies("campus")
+        assert ck and ck[0]["name"] == "s"
+
+
+class TestCookieDomainMatching:
+    def test_belongs_to_subdomains(self):
+        host = "campus.example"
+        assert webget._cookie_belongs_to("campus.example", host)
+        assert webget._cookie_belongs_to(".campus.example", host)
+        assert webget._cookie_belongs_to(".api.campus.example", host)
+        assert webget._cookie_belongs_to("api.campus.example", host)
+        # not unrelated, not suffix-trap
+        assert not webget._cookie_belongs_to("github.com", host)
+        assert not webget._cookie_belongs_to("notevil.com", host)
+        assert not webget._cookie_belongs_to("example.com.evil.com", host)
+
+    def test_domain_match_public(self):
+        assert webget._domain_match(".example.com", "api.example.com")
+        assert not webget._domain_match(".example.com", "example.com.evil.com")
+
+
+class TestLogoutScoping:
+    def test_logout_prunes_only_target_domain(self, isolated_env):
+        """Storage-state pruning: logout campus.example keeps github cookies."""
+        state = {
+            "cookies": [
+                _cookie("campus", ".campus.example"),
+                _cookie("api", ".api.campus.example"),
+                _cookie("gh", ".github.com"),
+            ]
+        }
+        new_state, removed = webget._prune_storage_cookies(state, "campus.example")
+        assert removed == 2
+        domains = {c["domain"] for c in new_state["cookies"]}
+        assert ".campus.example" not in domains
+        assert ".api.campus.example" not in domains
+        assert ".github.com" in domains  # unrelated survives
+
+    def test_logout_preserves_unrelated_domains_file(self, isolated_env):
+        """End-to-end through _write_json: the file on disk is updated."""
+        state = {"cookies": [_cookie("a", ".a.com"), _cookie("b", ".b.com")]}
+        p = webget.profile_state_path("work")
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            json.dump(state, f)
+        with open(p) as f:
+            loaded = json.load(f)
+        new_state, removed = webget._prune_storage_cookies(loaded, "a.com")
+        assert removed == 1
+        domains = {c["domain"] for c in new_state["cookies"]}
+        assert ".a.com" not in domains and ".b.com" in domains
+
+
+class TestSessionReuse:
+    def test_profile_cookies_sent_to_gated_page(self, fresh_cache, isolated_env):
+        server = fresh_cache
+        """Cookie-gated /cookie-gated returns 403 without a cookie, success with."""
+        res = asyncio.run(_fetch(server.url("/cookie-gated")))
+        assert _one(res)["status"] == "blocked"
+
+        # seed a profile with a cookie for the server host
+        host = server.host
+        p = webget.profile_state_path("local")
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            json.dump({"cookies": [_cookie("session", host)]}, f)
+
+        res = asyncio.run(_fetch(server.url("/cookie-gated"), profile="local"))
+        assert _one(res)["status"] == "success"
+
+    def test_explicit_cookies_win_over_profile(self, fresh_cache, isolated_env):
+        server = fresh_cache
+        ck = [_cookie("session", server.host)]
+        res = asyncio.run(_fetch(server.url("/cookie-gated"), cookies=ck))
+        assert _one(res)["status"] == "success"
+
+
+class TestProfileMeta:
+    def test_corrupt_state_reports_corrupt(self, isolated_env):
+        d = webget.profile_dir("broken")
+        os.makedirs(d, exist_ok=True)
+        with open(webget.profile_state_path("broken"), "w") as f:
+            f.write("{{{{")
+        assert webget._profile_meta("broken")["status"] == "corrupt"
+
+    def test_expired_cookies_reported_expired(self, isolated_env):
+        d = webget.profile_dir("old")
+        os.makedirs(d, exist_ok=True)
+        with open(webget.profile_state_path("old"), "w") as f:
+            json.dump({"cookies": [_cookie("s", ".x.com", expires=1000000000)]}, f)
+        assert webget._profile_meta("old")["status"] == "expired"

webget_cli-0.7.1/tests/test_adversarial_cache.py

@@ -0,0 +1,179 @@
+"""Adversarial cache tests: isolation keys, corruption, concurrency, atomicity."""
+
+import json
+import os
+import threading
+import time
+
+import webget_cli as webget
+
+
+class TestCacheKeys:
+    def test_profile_isolation(self):
+        a = webget._cache_path("https://x.com", None, None, 1000, "p1")
+        b = webget._cache_path("https://x.com", None, None, 1000, "p2")
+        assert a != b
+
+    def test_anonymous_vs_profile(self):
+        a = webget._cache_path("https://x.com", None, None, 1000, None)
+        b = webget._cache_path("https://x.com", None, None, 1000, "p1")
+        assert a != b
+
+    def test_headers_in_key(self):
+        a = webget._cache_path("https://x.com", None, {"A": "1"}, 1000, None)
+        b = webget._cache_path("https://x.com", None, {"A": "2"}, 1000, None)
+        assert a != b
+
+    def test_cookies_in_key(self):
+        ck = [{"name": "s", "value": "v", "domain": "x.com"}]
+        a = webget._cache_path("https://x.com", None, None, 1000, None)
+        b = webget._cache_path("https://x.com", ck, None, 1000, None)
+        assert a != b
+
+    def test_cookie_order_independent(self):
+        c1 = [
+            {"name": "a", "value": "1", "domain": "x.com"},
+            {"name": "b", "value": "2", "domain": "x.com"},
+        ]
+        c2 = [
+            {"name": "b", "value": "2", "domain": "x.com"},
+            {"name": "a", "value": "1", "domain": "x.com"},
+        ]
+        assert webget._cache_path("https://x.com", c1, None, 1000, None) == webget._cache_path(
+            "https://x.com", c2, None, 1000, None
+        )
+
+    def test_max_chars_in_key(self):
+        assert webget._cache_path("https://x.com", None, None, 500, None) != webget._cache_path(
+            "https://x.com", None, None, 900, None
+        )
+
+
+class TestCacheCorruption:
+    def test_corrupt_cache_returns_none(self, isolated_env):
+        p = webget._cache_path("https://x.com", None, None, 1000, None)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            f.write("{oops")
+        assert webget.cache_get("https://x.com", None, None, 1000, 3600) is None
+
+    def test_expired_cache_returns_none(self, isolated_env):
+        p = webget._cache_path("https://x.com", None, None, 1000, None)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w") as f:
+            json.dump({"status": "success"}, f)
+        os.utime(p, (time.time() - 7200, time.time() - 7200))  # 2h old, ttl 3600
+        assert webget.cache_get("https://x.com", None, None, 1000, 3600) is None
+
+
+class TestCacheConcurrency:
+    def test_concurrent_writes_never_corrupt(self, isolated_env):
+        """20 threads writing the same cache entry: file must stay valid JSON."""
+        url = "https://concurrent.test/page"
+        results = []
+
+        def writer(i):
+            try:
+                webget.cache_put(url, None, None, 1000, {"status": "success", "i": i}, None)
+                results.append(("ok", i))
+            except Exception as e:  # noqa: BLE001
+                results.append(("err", str(e)))
+
+        threads = [threading.Thread(target=writer, args=(i,)) for i in range(20)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert not [r for r in results if r[0] == "err"]
+        p = webget._cache_path(url, None, None, 1000, None)
+        with open(p) as f:
+            data = json.load(f)  # must parse
+        assert data["status"] == "success"
+
+    def test_concurrent_writers_use_unique_tmp(self, isolated_env):
+        """Deterministic regression (real bug caught 2026-08-08): concurrent
+        writers must NEVER share a tmp path. A shared '<path>.tmp' lets
+        threads interleave bytes in one file, so the atomic rename publishes
+        a corrupt document (observed as 'Extra data' JSONDecodeError). This
+        spies on os.replace instead of hoping the race window opens."""
+        url = "https://unique-tmp.test/page"
+        real_replace = os.replace
+        seen = []
+        lock = threading.Lock()
+
+        def spy(src, dst):
+            with lock:
+                seen.append(src)
+            return real_replace(src, dst)
+
+        os.replace = spy
+        try:
+            threads = [
+                threading.Thread(
+                    target=webget.cache_put,
+                    args=(url, None, None, 1000, {"status": "success", "i": i}, None),
+                )
+                for i in range(20)
+            ]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join()
+        finally:
+            os.replace = real_replace
+
+        final = webget._cache_path(url, None, None, 1000, None)
+        assert len(seen) == 20, f"expected 20 renames, got {len(seen)}"
+        assert len(set(seen)) == 20, "concurrent writers shared a tmp path"
+        for src in seen:
+            assert src.endswith(".tmp")
+            assert src != final
+        leftover = [f for f in os.listdir(isolated_env["cache"]) if f.endswith(".tmp")]
+        assert leftover == [], f"leftover tmp files: {leftover}"
+
+    def test_no_partial_file_on_write(self, isolated_env):
+        """Atomic write: cache_put must write via tmp + os.replace, so a
+        crash mid-write can never leave a truncated file at the real path."""
+
+        url = "https://atomic.test/page"
+        real_replace = os.replace
+        calls = []
+
+        def spy(src, dst):
+            calls.append((src, dst))
+            return real_replace(src, dst)
+
+        os.replace = spy
+        try:
+            webget.cache_put(url, None, None, 1000, {"status": "success", "x": "y" * 5000}, None)
+        finally:
+            os.replace = real_replace
+
+        assert calls, "cache_put must use os.replace (tmp + rename)"
+        tmp, dst = calls[0]
+        assert tmp.endswith(".tmp")
+        assert dst == webget._cache_path(url, None, None, 1000, None)
+        with open(dst) as f:
+            assert json.load(f)["x"] == "y" * 5000
+
+
+class TestCacheBehavior:
+    def test_hit_returns_normalized(self, isolated_env):
+        url = "https://cache.test/a"
+        webget.cache_put(
+            url, None, None, 1000, {"status": "success", "markdown": "hello world"}, None
+        )
+        hit = webget.cache_get(url, None, None, 1000, 3600)
+        assert hit is not None and hit["status"] == "success"
+
+    def test_failures_never_cached(self, isolated_env):
+        # cache_put is only called by record() on success; verify no path writes
+        # an error entry by calling with a marker.
+        url = "https://cache.test/err"
+        webget.cache_put(url, None, None, 1000, {"status": "error", "markdown": ""}, None)
+        hit = webget.cache_get(url, None, None, 1000, 3600)
+        # Best-effort cache: even error entries are storable; the ladder
+        # prevents them from being written. This test documents the contract:
+        # cache stores whatever record() passed it.
+        assert hit is None or hit["status"] == "error"  # tolerated

webget_cli-0.7.1/tests/test_adversarial_concurrency.py

@@ -0,0 +1,54 @@
+"""Adversarial concurrency tests: bounded parallelism, duplicate URLs,
+shared-state races in scrape_many."""
+
+import asyncio
+
+import webget_cli as webget
+
+
+async def _fetch_many(urls, **kw):
+    return await webget.scrape_many(urls, max_chars=2000, no_cache=True, **kw)
+
+
+class TestBoundedConcurrency:
+    def test_http_concurrency_is_bounded(self, server, fresh_cache, monkeypatch):
+        """100 unique URLs against /concurrency must never exceed the cap."""
+        urls = [server.url(f"/concurrency?i={i}") for i in range(100)]
+        server.reset_counters()
+        res = asyncio.run(_fetch_many(urls, per_url_timeout=10))
+        assert len(res) == 100
+        cap = webget._DEFAULT_CONCURRENCY
+        assert server.max_active <= cap, f"observed {server.max_active} concurrent, cap {cap}"
+
+    def test_custom_concurrency_cap(self, server, fresh_cache, monkeypatch):
+        """max_concurrency=3 must be honored."""
+        urls = [server.url(f"/concurrency?i={i}") for i in range(30)]
+        server.reset_counters()
+        res = asyncio.run(_fetch_many(urls, per_url_timeout=10, max_concurrency=3))
+        assert len(res) == 30
+        assert server.max_active <= 3, f"observed {server.max_active}, cap 3"
+
+
+class TestDuplicateURLs:
+    def test_duplicate_urls_fetched_once(self, server, fresh_cache):
+        """[u, u] must produce ONE attempt per URL, not duplicate work."""
+        url = server.url("/normal")
+        res = asyncio.run(_fetch_many([url, url]))
+        out = res[url]
+        assert out["attempts"] == 1
+        assert len(res) == 1  # deduped key
+
+
+class TestBatchScaling:
+    def test_batch_200_mixed(self, server, fresh_cache):
+        """Mixed batch (success, login, blocked, error) all complete."""
+        paths = ["/normal", "/login", "/403", "/429", "/thin", "/redirect"]
+        urls = [server.url(p) for p in paths] * 34  # 204 URLs
+        res = asyncio.run(_fetch_many(urls, per_url_timeout=10))
+        assert len(res) == len(set(urls))
+        statuses = {v["status"] for v in res.values()}
+        assert "success" in statuses
+        assert {"login_required", "blocked", "error"} & statuses
+
+    def test_empty_batch_returns_empty(self):
+        assert asyncio.run(_fetch_many([])) == {}

webget_cli-0.7.1/tests/test_adversarial_http.py

@@ -0,0 +1,153 @@
+"""Adversarial HTTP tests: URL handling, status codes, redirects, bodies."""
+
+import asyncio
+
+import pytest
+
+import webget_cli as webget
+
+
+async def _fetch(url, **kw):
+    return await webget.scrape_many([url], no_cache=True, **kw)
+
+
+def _one(res):
+    return res[next(iter(res))]
+
+
+# ---------- URL handling ----------
+
+
+class TestInvalidURLs:
+    @pytest.mark.parametrize(
+        "bad",
+        [
+            "not a url",
+            "://:",
+            "",
+            "ftp://example.com/file",
+            "file:///etc/passwd",
+            "data:text/html,hello",
+            "javascript:alert(1)",
+            "http://",
+            "http://exa mple.com",
+        ],
+    )
+    def test_invalid_urls_do_not_crash(self, bad):
+        res = asyncio.run(_fetch(bad))
+        out = _one(res)
+        assert out["status"] in ("error", "blocked")
+        assert "method" in out
+
+    def test_no_scheme_added_by_httpx(self):
+        # httpx refuses scheme-less URLs; ladder must record it as error.
+        res = asyncio.run(_fetch("example.com"))
+        assert _one(res)["status"] == "error"
+
+
+class TestConnectionFailures:
+    def test_connection_refused(self):
+        res = asyncio.run(_fetch("http://127.0.0.1:1/", per_url_timeout=5))
+        out = _one(res)
+        assert out["status"] == "error"
+        assert "method" in out  # any method is fine; must not crash
+
+    def test_dns_failure(self):
+        res = asyncio.run(
+            _fetch("http://nonexistent-host-webget-audit.invalid/", per_url_timeout=8)
+        )
+        assert _one(res)["status"] == "error"
+
+    def test_timeout(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/timeout?sec=5"), per_url_timeout=1))
+        assert _one(res)["status"] == "error"
+
+
+# ---------- status codes ----------
+
+
+class TestStatusCodes:
+    @pytest.mark.parametrize("path,expected", [("/401", "login_required"), ("/403", "blocked")])
+    def test_auth_statuses(self, fresh_cache, path, expected):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url(path)))
+        assert _one(res)["status"] == expected
+
+    @pytest.mark.parametrize("path", ["/404", "/500", "/429"])
+    def test_error_statuses(self, fresh_cache, path):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url(path)))
+        assert _one(res)["status"] in ("error", "blocked")  # 429 -> blocked
+
+    def test_403_login_words_login_required(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/403-login")))
+        assert _one(res)["status"] == "login_required"
+
+
+# ---------- redirects ----------
+
+
+class TestRedirects:
+    @pytest.mark.parametrize(
+        "path", ["/redirect", "/redirect-301", "/redirect-307", "/redirect-308"]
+    )
+    def test_redirects_followed(self, fresh_cache, path):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url(path)))
+        out = _one(res)
+        assert out["status"] == "success", out.get("error")
+
+    def test_redirect_chain(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/redirect-chain?n=5")))
+        assert _one(res)["status"] == "success"
+
+    def test_redirect_loop_errors(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/redirect-loop")))
+        out = _one(res)
+        # httpx raises TooManyRedirects after default max; must be error, not hang.
+        assert out["status"] == "error"
+        assert "redirect" in (out.get("error") or "").lower() or out["status"] == "error"
+
+
+# ---------- response bodies ----------
+
+
+class TestResponseBodies:
+    def test_empty_response(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/empty")))
+        # empty body -> markdown empty -> "content too thin" -> error terminal
+        assert _one(res)["status"] in ("error", "blocked")
+
+    def test_malformed_html(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/malformed")))
+        # html2text usually still extracts something; at minimum no crash
+        assert "status" in _one(res)
+
+    def test_binary_response(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/binary")))
+        assert _one(res)["status"] in ("error", "blocked", "success")
+
+    def test_json_response(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/json")))
+        assert _one(res)["status"] in ("error", "blocked", "success")
+
+    def test_gzip_response(self, fresh_cache):
+        server = fresh_cache
+        res = asyncio.run(_fetch(server.url("/gzip")))
+        assert _one(res)["status"] == "success"  # httpx auto-decompresses
+
+    def test_huge_response_is_bounded(self, fresh_cache):
+        server = fresh_cache
+        # 5MB body; scrape_many must truncate, not blow memory or hang.
+        res = asyncio.run(_fetch(server.url("/huge"), max_chars=1000))
+        out = _one(res)
+        assert out["status"] == "success"
+        assert len(out["markdown"]) <= 1000