shadey-mcp 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# Shadey MCP Server
+
+Stealth browser for AI agents. Bypasses Cloudflare, DataDome, and every anti-bot system.
+
+## Setup
+
+```bash
+npm install @anthropic-ai/shadey-mcp
+```
+
+Set your API key:
+```bash
+export SHADEY_API_KEY=sk_your_key
+```
+
+## Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "shadey": {
+      "command": "npx",
+      "args": ["@anthropic-ai/shadey-mcp"],
+      "env": {
+        "SHADEY_API_KEY": "sk_your_key"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `browse` | Navigate to any URL through a stealth browser |
+| `extract` | Extract data using CSS selectors |
+| `screenshot` | Take a screenshot of the current page |
+| `evaluate` | Run JavaScript in the page |
+| `content` | Get full page HTML |
+| `click` | Click with human-like mouse movement |
+| `type_text` | Type with realistic keystroke timing |
+| `scroll` | Scroll with natural momentum |
+| `close_session` | Close browser and destroy all data |
+
+## Example
+
+Ask Claude: "Go to github.com/torvalds and tell me about his pinned repositories"
+
+Claude will use the `browse` tool to navigate, then `extract` to pull data — all through a stealth browser that passes anti-bot detection.
+
+## Get an API key
+
+Sign up at [shadey.dev](https://shadey.dev)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const API_URL = process.env.SHADEY_API_URL || "https://api.shadey.dev";
+const API_KEY = process.env.SHADEY_API_KEY || "";
+if (!API_KEY) {
+    console.error("SHADEY_API_KEY environment variable required");
+    process.exit(1);
+}
+async function shadeyFetch(path, opts = {}) {
+    const res = await fetch(`${API_URL}${path}`, {
+        ...opts,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${API_KEY}`,
+            ...opts.headers,
+        },
+    });
+    if (res.status === 204)
+        return {};
+    return res.json();
+}
+// Active session for multi-step browsing
+let activeSession = null;
+async function ensureSession() {
+    if (activeSession)
+        return activeSession;
+    const data = await shadeyFetch("/v1/sessions", {
+        method: "POST",
+        body: JSON.stringify({}),
+    });
+    activeSession = data.id;
+    return data.id;
+}
+async function destroySession() {
+    if (activeSession) {
+        await shadeyFetch(`/v1/sessions/${activeSession}`, { method: "DELETE" }).catch(() => { });
+        activeSession = null;
+    }
+}
+const server = new index_js_1.Server({ name: "shadey-browser", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "browse",
+            description: "Navigate to a URL using a stealth browser that bypasses Cloudflare, DataDome, and other anti-bot systems. Returns the page title, URL, and content. The browser has a unique fingerprint and human-like behavioral patterns per session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    url: { type: "string", description: "URL to navigate to" },
+                    wait_ms: { type: "number", description: "Milliseconds to wait after navigation (default 3000)", default: 3000 },
+                },
+                required: ["url"],
+            },
+        },
+        {
+            name: "extract",
+            description: "Extract data from the current page using CSS selectors. Must call 'browse' first to navigate to a page.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    selector: { type: "string", description: "CSS selector to extract" },
+                    attribute: { type: "string", description: "HTML attribute to extract (default: textContent)", default: "textContent" },
+                    all: { type: "boolean", description: "Extract all matching elements (default: false)", default: false },
+                },
+                required: ["selector"],
+            },
+        },
+        {
+            name: "screenshot",
+            description: "Take a screenshot of the current page. Must call 'browse' first. Returns a JPEG image.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "evaluate",
+            description: "Run JavaScript in the current page context. Must call 'browse' first.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    expression: { type: "string", description: "JavaScript to evaluate" },
+                },
+                required: ["expression"],
+            },
+        },
+        {
+            name: "content",
+            description: "Get the full HTML of the current page. Must call 'browse' first.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "click",
+            description: "Click at coordinates on the current page with human-like mouse movement (Fitts' law trajectory, corrective submovements). Must call 'browse' first.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    x: { type: "number", description: "X coordinate" },
+                    y: { type: "number", description: "Y coordinate" },
+                },
+                required: ["x", "y"],
+            },
+        },
+        {
+            name: "type_text",
+            description: "Type text with human-like keystroke timing (QWERTY bigram model). Must call 'browse' first.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    text: { type: "string", description: "Text to type" },
+                },
+                required: ["text"],
+            },
+        },
+        {
+            name: "scroll",
+            description: "Scroll the page with human-like momentum. Positive = down, negative = up. Must call 'browse' first.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    distance: { type: "number", description: "Pixels to scroll (positive = down)" },
+                },
+                required: ["distance"],
+            },
+        },
+        {
+            name: "close_session",
+            description: "Close the current browser session and destroy all data.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+    ],
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "browse": {
+                const sid = await ensureSession();
+                const url = args.url;
+                const wait_ms = args.wait_ms || 3000;
+                const nav = await shadeyFetch(`/v1/sessions/${sid}/navigate`, {
+                    method: "POST",
+                    body: JSON.stringify({ url, wait_ms }),
+                });
+                // Also get page content for the LLM
+                const content = await shadeyFetch(`/v1/sessions/${sid}/content`, {
+                    method: "POST",
+                });
+                // Truncate HTML to avoid token overflow
+                const html = (content.html || "").slice(0, 50000);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Navigated to: ${nav.url}\nTitle: ${nav.title}\n\nPage HTML (truncated to 50KB):\n${html}`,
+                        },
+                    ],
+                };
+            }
+            case "extract": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/extract`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        selector: args.selector,
+                        attribute: args.attribute || "textContent",
+                        all: args.all || false,
+                    }),
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "screenshot": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/screenshot`, {
+                    method: "POST",
+                });
+                // Return as base64 image
+                const base64 = (data.data || "").replace("data:image/jpeg;base64,", "");
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: base64,
+                            mimeType: "image/jpeg",
+                        },
+                    ],
+                };
+            }
+            case "evaluate": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/evaluate`, {
+                    method: "POST",
+                    body: JSON.stringify({ expression: args.expression }),
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(data, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "content": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/content`, {
+                    method: "POST",
+                });
+                const html = (data.html || "").slice(0, 100000);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `URL: ${data.url}\nLength: ${data.length} bytes\n\n${html}`,
+                        },
+                    ],
+                };
+            }
+            case "click": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/behave`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        action: "move_and_click",
+                        target_x: args.x,
+                        target_y: args.y,
+                        target_width: 30,
+                    }),
+                });
+                return {
+                    content: [{ type: "text", text: `Clicked at (${args.x}, ${args.y}) — ${data.commands_sent} CDP commands` }],
+                };
+            }
+            case "type_text": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/behave`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        action: "type",
+                        text: args.text,
+                        typing_context: "form",
+                    }),
+                });
+                return {
+                    content: [{ type: "text", text: `Typed "${args.text}" — ${data.commands_sent} keystrokes` }],
+                };
+            }
+            case "scroll": {
+                const sid = await ensureSession();
+                const data = await shadeyFetch(`/v1/sessions/${sid}/behave`, {
+                    method: "POST",
+                    body: JSON.stringify({
+                        action: "scroll",
+                        distance: args.distance,
+                    }),
+                });
+                return {
+                    content: [{ type: "text", text: `Scrolled ${args.distance}px — ${data.commands_sent} events` }],
+                };
+            }
+            case "close_session": {
+                await destroySession();
+                return {
+                    content: [{ type: "text", text: "Session closed. Browser destroyed, fingerprint erased." }],
+                };
+            }
+            default:
+                return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+        }
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+// Cleanup on exit
+process.on("SIGINT", async () => {
+    await destroySession();
+    process.exit(0);
+});
+process.on("SIGTERM", async () => {
+    await destroySession();
+    process.exit(0);
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "shadey-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Shadey — stealth browser sessions for AI agents",
+  "main": "dist/index.js",
+  "bin": {
+    "shadey-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "browser",
+    "stealth",
+    "ai",
+    "agents",
+    "shadey",
+    "cloudflare",
+    "scraping"
+  ],
+  "author": "Shadey",
+  "license": "MIT",
+  "homepage": "https://shadey.dev",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}