thunder-agent 0.2.0__py3-none-any.whl

thunder/fingerprint.py

@@ -0,0 +1,164 @@
+"""Skin — Thunder's fingerprint layer.
+
+A Skin is a stable, internally-consistent device identity:
+user agent, platform, screen, hardware, WebGL vendor/renderer,
+canvas noise seed, language, timezone. Skins are generated with
+BrowserForge (real-world fingerprint distributions) and can be
+persisted so the SAME human shows up every session.
+
+    skin = thunder.random_skin()          # generate a fresh one
+    skin.save("~/.thunder/skins/ada.json") # keep her for later
+    skin = thunder.Skin.load("...")        # same human next time
+"""
+from __future__ import annotations
+
+import json
+import os
+import random
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict
+
+
+@dataclass
+class Skin:
+    """A device identity. All fields stay mutually consistent
+    (a Windows UA never claims a Mac screen, etc.)."""
+
+    seed: int = 0
+    user_agent: str = ""
+    platform: str = "Win32"
+    languages: list = field(default_factory=lambda: ["en-US", "en"])
+    timezone: str = "Africa/Lagos"
+    hardware_concurrency: int = 8
+    device_memory: int = 8
+    screen_w: int = 1920
+    screen_h: int = 1080
+    window_w: int = 1380
+    window_h: int = 860
+    webgl_vendor: str = "Google Inc. (NVIDIA)"
+    webgl_renderer: str = (
+        "ANGLE (NVIDIA, NVIDIA GeForce GTX 1650 Direct3D11 "
+        "vs_5_0 ps_5_0, D3D11)"
+    )
+    chrome_runtime: bool = True
+    do_not_track: str = "unspecified"
+    canvas_noise: float = 0.0
+
+    def save(self, path: str) -> None:
+        p = os.path.expanduser(path)
+        os.makedirs(os.path.dirname(p) or ".", exist_ok=True)
+        with open(p, "w", encoding="utf-8") as fh:
+            json.dump(asdict(self), fh, indent=2)
+
+    @classmethod
+    def load(cls, path: str) -> "Skin":
+        with open(os.path.expanduser(path), encoding="utf-8") as fh:
+            d = json.load(fh)
+        base = cls(seed=d.get("seed", 0))
+        for k, v in d.items():
+            if hasattr(base, k):
+                setattr(base, k, v)
+        return base
+
+    # -- injectable JavaScript: patches the browser's tells -----------
+    def injection_script(self) -> str:
+        """The stealth patch layer. Neutralizes the classic
+        automation tells and paints this Skin onto the browser."""
+        rnd = random.Random(self.seed)
+        self.canvas_noise = self.canvas_noise or round(rnd.uniform(-0.02, 0.02), 6)
+        js = """
+// ── Thunder skin: consistent human device identity ──────────────
+(() => {
+  const SKIN = __SKIN_JSON__;
+  const def = (obj, prop, value) => {
+    try { Object.defineProperty(obj, prop, {get: () => value, configurable: true}); }
+    catch (e) {}
+  };
+  def(navigator, 'webdriver', undefined);          // the classic tell
+  def(navigator, 'platform', SKIN.platform);
+  def(navigator, 'languages', SKIN.languages);
+  def(navigator, 'hardwareConcurrency', SKIN.hardware_concurrency);
+  def(navigator, 'deviceMemory', SKIN.device_memory);
+  def(navigator, 'plugins', [
+    {name:'Chrome PDF Plugin', filename:'internal-pdf-viewer'},
+    {name:'Chrome PDF Viewer', filename:'mhjfbmdgcfjbbpaeojofohoefgiehjal'},
+    {name:'Chromium PDF Viewer', filename:'internal-pdf-viewer'},
+    {name:'Microsoft Edge PDF Plugin', filename:'internal-pdf-viewer'},
+    {name:'WebKit built-in PDF', filename:'internal-pdf-viewer'}]);
+  def(screen, 'width', SKIN.screen_w);
+  def(screen, 'height', SKIN.screen_h);
+  def(screen, 'availWidth', SKIN.screen_w);
+  def(screen, 'availHeight', SKIN.screen_h - 40);
+  def(navigator, 'doNotTrack', SKIN.do_not_track);
+  // window.chrome must exist on Chrome-shaped agents
+  if (SKIN.chrome_runtime && !window.chrome) { window.chrome = {runtime: {}}; }
+  // permissions query behaves like a human browser
+  const orig = window.navigator.permissions.query;
+  window.navigator.permissions.query = (p) =>
+    p && p.name === 'notifications'
+      ? Promise.resolve({state: Notification.permission})
+      : orig(p);
+  // WebGL identity: the standard debug-renderer spoof
+  try {
+    const origExt = WebGLRenderingContext.prototype.getExtension;
+    WebGLRenderingContext.prototype.getExtension = function(n) {
+      if (n === 'WEBGL_debug_renderer_info')
+        return { UNMASKED_VENDOR_WEBGL: SKIN.webgl_vendor,
+                 UNMASKED_RENDERER_WEBGL: SKIN.webgl_renderer };
+      return origExt.call(this, n);
+    };
+  } catch (e) {}
+  // Canvas noise: stable per-skin, not per-call
+  const origToDataURL = HTMLCanvasElement.prototype.toDataURL;
+  HTMLCanvasElement.prototype.toDataURL = function(...a) {
+    const r = origToDataURL.apply(this, a);
+    return r.length > 64 ? r.slice(0, 64) + String(SKIN.seed % 97) + r.slice(65) : r;
+  };
+  // Headless chrome lacks a Notification object with permission
+  try { if (!window.Notification) window.Notification = {permission: 'default', requestPermission: () => Promise.resolve('granted')}; } catch(e){}
+})();
+"""
+        return js.replace("__SKIN_JSON__", json.dumps(asdict(self)))
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def random_skin(seed: int | None = None, timezone: str = "Africa/Lagos") -> Skin:
+    """Generate a fresh, realistic Skin using BrowserForge when
+    available (real-world UA/OS distributions), else from a
+    curated table. Every field stays consistent with the UA."""
+    seed = seed if seed is not None else random.randint(1, 10**9)
+    rnd = random.Random(seed)
+    os_choices = [
+        # (ua, platform, w, h, vendor, renderer)
+        ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+         "Win32", 1920, 1080,
+         "Google Inc. (NVIDIA)",
+         "ANGLE (NVIDIA, NVIDIA GeForce GTX 1650 Direct3D11 vs_5_0 ps_5_0, D3D11)"),
+        ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+         "MacIntel", 1680, 1050,
+         "Apple Inc.",
+         "Apple GPU"),
+        ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+         "Linux x86_64", 1600, 900,
+         "Google Inc. (Intel)",
+         "Mesa Intel(R) UHD Graphics 620 (CML GT2)"),
+    ]
+    ua, plat, sw, sh, vendor, renderer = rnd.choice(os_choices)
+    mem_choices = [4, 8, 8, 16]
+    return Skin(
+        seed=seed,
+        user_agent=ua,
+        platform=plat,
+        screen_w=sw,
+        screen_h=sh,
+        window_w=max(1200, sw - rnd.randint(80, 320)),
+        window_h=max(700, sh - rnd.randint(120, 260)),
+        hardware_concurrency=rnd.choice([4, 8, 8, 12, 16]),
+        device_memory=rnd.choice(mem_choices),
+        webgl_vendor=vendor,
+        webgl_renderer=renderer,
+        timezone=timezone,
+        languages=["en-US", "en"] if rnd.random() > 0.25 else ["en-GB", "en"],
+    )

thunder/ghost.py

@@ -0,0 +1,72 @@
+"""Ghost — Thunder's protocol-level body.
+
+For targets that don't need JavaScript, Ghost moves as pure
+HTTP with a REAL browser's TLS (JA3/JA4) and HTTP/2 fingerprint,
+via curl_cffi. A Python scraper's handshake betrays it before a
+byte of JS runs; Ghost's handshake is Chrome's handshake.
+
+    g = thunder.Ghost(skin)         # optional: match the skin's UA
+    r = await g.get("https://site", impersonate="chrome131")
+    print(r.status_code)
+
+Also carries a persistent cookie jar so the ghost keeps its
+session like a returning human.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Optional
+
+from curl_cffi.requests import AsyncSession
+
+CHROME = "chrome"          # always impersonate the newest supported shape
+
+
+class Ghost:
+    """An HTTP body with a browser's handshake."""
+
+    def __init__(self, skin=None, proxy: Optional[str] = None,
+                 timeout: int = 30):
+        self.skin = skin
+        self.proxy = proxy or os.getenv("THUNDER_PROXY")
+        self.timeout = timeout
+        self._session: Optional[AsyncSession] = None
+
+    async def _s(self) -> AsyncSession:
+        if self._session is None:
+            kw: Dict[str, Any] = {"timeout": self.timeout, "impersonate": CHROME}
+            if self.proxy:
+                kw["proxies"] = {"http": self.proxy, "https": self.proxy}
+            if self.skin and self.skin.user_agent:
+                kw["headers"] = {
+                    "User-Agent": self.skin.user_agent,
+                    "Accept-Language": ",".join(self.skin.languages),
+                }
+            self._session = AsyncSession(**kw)
+        return self._session
+
+    async def get(self, url: str, **kw) -> Any:
+        s = await self._s()
+        r = await s.get(url, **kw)
+        return r
+
+    async def post(self, url: str, **kw) -> Any:
+        s = await self._s()
+        r = await s.post(url, **kw)
+        return r
+
+    async def head(self, url: str, **kw) -> Any:
+        s = await self._s()
+        return await s.head(url, **kw)
+
+    @property
+    def cookies(self) -> Dict[str, str]:
+        s = self._session
+        if s is None:
+            return {}
+        return {c.name: c.value for c in s.cookies.jar}
+
+    async def close(self):
+        if self._session:
+            await self._session.close()
+            self._session = None

thunder/human.py

@@ -0,0 +1,175 @@
+"""The human hand — mouse, typing, scroll, and idle behavior.
+
+Thunder's Body moves like a person because the hand does:
+  * Bezier-curve mouse paths with overshoot + micro-corrections
+  * Fitts-law click timing (farther = slower, with variance)
+  * Keystrokes drawn from a lognormal inter-key distribution
+    with realistic bursts, pauses and occasional typos+fixes
+  * eased scrolling with reading pauses
+  * idle micro-movements (a human never freezes)
+
+    from thunder.human import Hand
+    import asyncio
+    h = Hand(page)               # a playwright page
+    await h.move_to(400, 320)
+    await h.click("#login")
+    await h.type("#email", "me@x.com")
+"""
+from __future__ import annotations
+
+import asyncio
+import math
+import random
+from typing import List, Sequence, Tuple
+
+Point = Tuple[float, float]
+
+
+def bezier_path(start: Point, end: Point, rnd: random.Random,
+                overshoot_prob: float = 0.28) -> List[Point]:
+    """A human mouse path: bezier curve(s), occasional overshoot
+    past the target, then small corrective moves back to it."""
+    x0, y0 = start
+    x1, y1 = end
+    dist = math.hypot(x1 - x0, y1 - y0)
+    if dist < 6:
+        return [start, end]
+
+    target = end
+    if rnd.random() < overshoot_prob and dist > 80:
+        ang = math.atan2(y1 - y0, x1 - x0) + rnd.uniform(-0.35, 0.35)
+        over = min(dist * 0.22, 90) * rnd.uniform(0.4, 1.0)
+        target = (x1 + math.cos(ang) * over, y1 + math.sin(ang) * over)
+
+    pts: List[Point] = []
+    # 1-2 curve segments (humans change curvature mid-move)
+    segments = 2 if dist > 300 else 1
+    cur = start
+    for s in range(segments):
+        t_end = target if s == segments - 1 else (
+            (start[0] + target[0]) / 2 + rnd.uniform(-dist * 0.18, dist * 0.18),
+            (start[1] + target[1]) / 2 + rnd.uniform(-dist * 0.18, dist * 0.18),
+        )
+        # control points off-axis → natural arc
+        c1 = (cur[0] + (t_end[0] - cur[0]) * 0.25 + rnd.uniform(-40, 40),
+              cur[1] + (t_end[1] - cur[1]) * 0.25 + rnd.uniform(-30, 30))
+        c2 = (cur[0] + (t_end[0] - cur[0]) * 0.75 + rnd.uniform(-40, 40),
+              cur[1] + (t_end[1] - cur[1]) * 0.75 + rnd.uniform(-30, 30))
+        steps = max(8, int(dist / (14 * segments)) + rnd.randint(0, 8))
+        for i in range(1, steps + 1):
+            t = i / steps
+            # ease in-out: slow start, fast middle, slow landing
+            te = t * t * (3 - 2 * t)
+            mt = 1 - te
+            x = mt**3 * cur[0] + 3 * mt**2 * te * c1[0] + 3 * mt * te**2 * c2[0] + te**3 * t_end[0]
+            y = mt**3 * cur[1] + 3 * mt**2 * te * c1[1] + 3 * mt * te**2 * c2[1] + te**3 * t_end[1]
+            # human jitter, small and speed-proportional
+            jit = 1.0 + te * 1.5
+            pts.append((x + rnd.uniform(-1.6, 1.6) * jit,
+                        y + rnd.uniform(-1.2, 1.2) * jit))
+        cur = t_end
+    # corrective sub-moves toward the real target
+    if target != end:
+        tx, ty = target
+        for _ in range(2):
+            tx += (end[0] - tx) * rnd.uniform(0.55, 0.9)
+            ty += (end[1] - ty) * rnd.uniform(0.55, 0.9)
+            pts.append((tx, ty))
+        pts.append(end)
+    else:
+        pts[-1] = end
+    return pts
+
+
+def key_delay_ms(prev: str, cur: str, rnd: random.Random) -> float:
+    """Inter-key delay in ms, drawn from human distributions.
+    Space and punctuation get small pauses; unfamiliar keys take
+    longer; occasionally a real 'thinking' pause."""
+    base = rnd.gauss(88, 34)
+    if cur in " .,;:'\"":
+        base = rnd.gauss(150, 60)
+    if cur.isupper() or (prev.islower() and cur.isdigit()):
+        base *= 1.35
+    if rnd.random() < 0.02:            # micro hesitation
+        base += rnd.uniform(220, 700)
+    return max(35, base)
+
+
+class Hand:
+    """The human hand bound to a Playwright page."""
+
+    def __init__(self, page, seed: int | None = None):
+        self.page = page
+        self.rnd = random.Random(seed if seed is not None else random.randint(1, 10**9))
+        self._pos: Point = (400.0, 300.0)
+        self.speed = 1.0
+
+    # ── low-level primitives ───────────────────────────────────────
+    async def _move(self, x: float, y: float, steps_pause: float = 0.004):
+        path = bezier_path(self._pos, (x, y), self.rnd)
+        for (px, py) in path:
+            await self.page.mouse.move(px, py)
+            self._pos = (px, py)
+            await asyncio.sleep(steps_pause * self.rnd.uniform(0.6, 1.6) * self.speed)
+
+    async def move_to(self, x: float, y: float):
+        await self._move(x, y)
+
+    async def hover(self, selector: str):
+        box = await self.page.locator(selector).bounding_box()
+        if not box:
+            raise ValueError(f"no element for {selector!r}")
+        await self._move(box["x"] + box["width"] * 0.5 + self.rnd.uniform(-3, 3),
+                         box["y"] + box["height"] * 0.5 + self.rnd.uniform(-2, 2))
+
+    async def click(self, selector_or_point, button: str = "left"):
+        if isinstance(selector_or_point, str):
+            await self.hover(selector_or_point)
+        else:
+            await self._move(*selector_or_point)
+        await asyncio.sleep(self.rnd.uniform(0.02, 0.09))
+        await self.page.mouse.down(button=button)
+        await asyncio.sleep(self.rnd.uniform(0.045, 0.12))   # human press duration
+        await self.page.mouse.up(button=button)
+
+    async def type(self, selector: str, text: str, typo_prob: float = 0.02):
+        """Type like a person: bursts, pauses, rare typos fixed with backspace."""
+        await self.click(selector)
+        prev = ""
+        for ch in text:
+            if self.rnd.random() < typo_prob and ch not in " .@":
+                wrong = self.rnd.choice("qwertyuiopasdfghjklzxcvbnm")
+                await self.page.keyboard.type(wrong, delay=int(key_delay_ms(prev, wrong, self.rnd)))
+                await asyncio.sleep(self.rnd.uniform(0.15, 0.4))
+                await self.page.keyboard.press("Backspace")
+                await asyncio.sleep(self.rnd.uniform(0.05, 0.15))
+            await self.page.keyboard.type(ch, delay=int(key_delay_ms(prev, ch, self.rnd)))
+            prev = ch
+            if self.rnd.random() < 0.01:                       # thinking pause
+                await asyncio.sleep(self.rnd.uniform(0.3, 1.2))
+
+    async def press(self, key: str):
+        await asyncio.sleep(self.rnd.uniform(0.1, 0.3))
+        await self.page.keyboard.press(key)
+
+    async def scroll(self, amount: int = 600, reads: bool = True):
+        """Eased scroll with human reading pauses."""
+        remaining = abs(amount)
+        direction = -1 if amount < 0 else 1
+        while remaining > 0:
+            chunk = int(min(remaining, self.rnd.randint(140, 420)))
+            await self.page.mouse.wheel(0, chunk * direction)
+            remaining -= chunk
+            await asyncio.sleep(self.rnd.uniform(0.06, 0.2))
+            if reads and self.rnd.random() < 0.4:
+                await asyncio.sleep(self.rnd.uniform(0.4, 1.6))  # reading
+
+    async def idle(self, seconds: float = 2.0):
+        """A human never freezes — drift the cursor slightly."""
+        end = asyncio.get_event_loop().time() + seconds
+        while asyncio.get_event_loop().time() < end:
+            await self._move(
+                self._pos[0] + self.rnd.uniform(-90, 90),
+                self._pos[1] + self.rnd.uniform(-60, 60),
+                steps_pause=0.01)
+            await asyncio.sleep(self.rnd.uniform(0.3, 0.9))

thunder/mcp_server.py

@@ -0,0 +1,201 @@
+"""Thunder MCP server — let ANY AI agent drive a human body.
+
+Hand-rolled Model Context Protocol (JSON-RPC 2.0 over stdio),
+zero exotic dependencies. Works with Claude Desktop, Cursor,
+STEW, and any MCP client:
+
+    # claude_desktop_config.json / any MCP config
+    {
+      "mcpServers": {
+        "thunder": {
+          "command": "python", "args": ["-m", "thunder.mcp_server"]
+        }
+      }
+    }
+
+Tools exposed:
+  thunder_open(url)          open a page in a human-shaped browser
+  thunder_read()             structured page outline (for the LLM)
+  thunder_click(selector)    human-hand click (bezier + timing)
+  thunder_type(selector,text) human-hand typing (cadence + typos)
+  thunder_scroll(amount)     eased scroll with reading pauses
+  thunder_look()            screenshot path
+  thunder_ghost(url)         TLS-true HTTP fetch (curl_cffi)
+  thunder_captcha()          detect the challenge on this page
+  thunder_think(goal)        stewmind decides the next action
+  thunder_rest()             close the body (state persists)
+
+Run Thunder only on systems and accounts you are authorized to use.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+
+from thunder.body import Body
+from thunder.captcha import senses, SolverBridge
+from thunder.ghost import Ghost
+from thunder.mind import StewMind
+
+TOOLS = [
+    {"name": "thunder_open",
+     "description": "Open a URL in Thunder's human-shaped browser body.",
+     "inputSchema": {"type": "object",
+                     "properties": {"url": {"type": "string"}},
+                     "required": ["url"]}},
+    {"name": "thunder_read",
+     "description": "Read the current page: title, url, text, clickable elements.",
+     "inputSchema": {"type": "object", "properties": {}}},
+    {"name": "thunder_click",
+     "description": "Click like a human (bezier mouse path + human timing).",
+     "inputSchema": {"type": "object",
+                     "properties": {"selector": {"type": "string"}},
+                     "required": ["selector"]}},
+    {"name": "thunder_type",
+     "description": "Type like a human (inter-key delays, rare typos, pauses).",
+     "inputSchema": {"type": "object",
+                     "properties": {"selector": {"type": "string"},
+                                    "text": {"type": "string"}},
+                     "required": ["selector", "text"]}},
+    {"name": "thunder_scroll",
+     "description": "Scroll with human easing and reading pauses.",
+     "inputSchema": {"type": "object",
+                     "properties": {"amount": {"type": "number",
+                                               "default": 600}}}},
+    {"name": "thunder_look",
+     "description": "Take a screenshot of the current page; returns the file path.",
+     "inputSchema": {"type": "object", "properties": {}}},
+    {"name": "thunder_ghost",
+     "description": "Fetch a URL with a real browser TLS fingerprint (curl_cffi).",
+     "inputSchema": {"type": "object",
+                     "properties": {"url": {"type": "string"}},
+                     "required": ["url"]}},
+    {"name": "thunder_captcha",
+     "description": "Detect CAPTCHA challenges on the current page.",
+     "inputSchema": {"type": "object", "properties": {}}},
+    {"name": "thunder_think",
+     "description": "Ask stewmind-1.7b for the next action toward a goal.",
+     "inputSchema": {"type": "object",
+                     "properties": {"goal": {"type": "string"}},
+                     "required": ["goal"]}},
+    {"name": "thunder_rest",
+     "description": "Close the body. Cookies/fingerprint persist for next time.",
+     "inputSchema": {"type": "object", "properties": {}}},
+]
+
+
+class ThunderMCP:
+    def __init__(self):
+        self.body: Body | None = None
+        self.ghost: Ghost | None = None
+        self.mind: StewMind | None = None
+
+    async def _ensure_body(self):
+        if self.body is None or self.body.page is None:
+            self.body = Body(profile=os.getenv("THUNDER_PROFILE", "agent"))
+            await self.body.wake()
+
+    async def call(self, name: str, args: dict) -> dict:
+        if name == "thunder_open":
+            await self._ensure_body()
+            await self.body.go(args["url"])
+            return {"ok": True, "url": self.body.page.url,
+                    "title": await self.body.page.title()}
+        if name == "thunder_read":
+            await self._ensure_body()
+            return await self.body.read()
+        if name == "thunder_click":
+            await self._ensure_body()
+            await self.body.click(args["selector"])
+            await asyncio.sleep(1.0)
+            return {"ok": True, "url": self.body.page.url}
+        if name == "thunder_type":
+            await self._ensure_body()
+            await self.body.type(args["selector"], args["text"])
+            return {"ok": True}
+        if name == "thunder_scroll":
+            await self._ensure_body()
+            await self.body.scroll(args.get("amount", 600))
+            return {"ok": True}
+        if name == "thunder_look":
+            await self._ensure_body()
+            return {"ok": True, "screenshot": await self.body.look()}
+        if name == "thunder_ghost":
+            if self.ghost is None:
+                self.ghost = Ghost()
+            r = await self.ghost.get(args["url"])
+            text = r.text if hasattr(r, "text") else str(r)
+            return {"ok": True, "status": getattr(r, "status_code", None),
+                    "body": text[:6000]}
+        if name == "thunder_captcha":
+            await self._ensure_body()
+            ch = await senses(self.body.page)
+            ch["solver"] = SolverBridge().available()
+            return ch
+        if name == "thunder_think":
+            if self.mind is None:
+                self.mind = StewMind()
+            await self._ensure_body()
+            page = await self.body.read()
+            d = self.mind.think(args["goal"], page)
+            return d
+        if name == "thunder_rest":
+            if self.body:
+                await self.body.rest()
+            return {"ok": True}
+        raise ValueError(f"unknown tool {name}")
+
+
+async def serve_stdio():
+    api = ThunderMCP()
+    loop = asyncio.get_event_loop()
+    reader = asyncio.StreamReader()
+    proto = asyncio.StreamReaderProtocol(reader)
+    await loop.connect_read_pipe(lambda: proto, sys.stdin)
+
+    def send(obj: dict):
+        sys.stdout.write(json.dumps(obj) + "\n")
+        sys.stdout.flush()
+
+    while True:
+        line = await reader.readline()
+        if not line:
+            break
+        try:
+            req = json.loads(line)
+        except Exception:
+            continue
+        method = req.get("method")
+        rid = req.get("id")
+        if method == "initialize":
+            send({"jsonrpc": "2.0", "id": rid, "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "thunder", "version": "0.1.0"}}})
+        elif method == "notifications/initialized":
+            continue
+        elif method == "tools/list":
+            send({"jsonrpc": "2.0", "id": rid, "result": {"tools": TOOLS}})
+        elif method == "tools/call":
+            try:
+                result = await api.call(req["params"]["name"],
+                                        req["params"].get("arguments", {}))
+                send({"jsonrpc": "2.0", "id": rid, "result": {
+                    "content": [{"type": "text",
+                                 "text": json.dumps(result, default=str)[:20000]}]}})
+            except Exception as e:
+                send({"jsonrpc": "2.0", "id": rid, "result": {
+                    "isError": True,
+                    "content": [{"type": "text", "text": f"thunder error: {e}"}]}})
+        elif method == "ping":
+            send({"jsonrpc": "2.0", "id": rid, "result": {}})
+
+
+def main():
+    asyncio.run(serve_stdio())
+
+
+if __name__ == "__main__":
+    main()