एजेंटिक वेब क्रॉलर जिसमें एंटी-डिटेक्शन, विज़न फ़ॉलबैक, और पीयर-टू-पीयर मेश है।
एंडपॉइंट्स · मेश · एंटी-डिटेक्शन · Ghost Protocol · लाइव स्ट्रीम · MCP टूल्स · त्वरित आरंभ · बेंचमार्क · आर्किटेक्चर
एक फुल-स्टैक वेब क्रॉलिंग इंजन जिसमें JavaScript रेंडरिंग, Camoufox एंटी-डिटेक्ट ब्राउज़र, प्रति-अनुरोध प्रॉक्सी रूटिंग, और स्वायत्त एजेंट लूप्स शामिल हैं। नेटिव Rust एक्सट्रैक्शन इंजन के साथ पृष्ठों को साफ मार्कडाउन में बदलता है। जब Cloudflare, CAPTCHAs या JavaScript वॉल के कारण मानक क्रॉलिंग अवरुद्ध होती है, तो Ghost Protocol एक स्क्रीनशॉट लेता है और विज़न AI (Claude, GPT-4o, या Ollama) के माध्यम से सामग्री निकालता है। एक ही सत्र में OpenAI, Anthropic और Ollama में मल्टी-प्रोवाइडर LLM ऑर्केस्ट्रेशन को सपोर्ट करता है। नोड्स गॉसिप-आधारित पीयर-टू-पीयर मेश पर समन्वय करते हैं।
क्यों Grub
हमने हर प्रमुख क्रॉलर से सुविधाएँ एकीकृत कीं — फिर वह जोड़ा जो किसी के पास नहीं है।
स्व-होस्टेड क्रॉलर
क्लाउड/प्रबंधित क्रॉलर
केवल Grub में Ghost Protocol है — स्वचालित विज़न-आधारित फ़ॉलबैक जो अवरुद्ध पृष्ठों का स्क्रीनशॉट लेता है और जब मानक क्रॉलिंग विफल होती है तो LLM के माध्यम से सामग्री निकालता है। रोकथाम (Camoufox + प्रॉक्सी + स्टील्थ) 95% ब्लॉक को संभालती है। Ghost Protocol बाकी को संभालता है।
एपीआई एंडपॉइंट्स
कोर क्रॉलिंग
एजेंट (मोड B)
जॉब प्रबंधन
रिमोट कैश
सत्र प्रबंधन
लाइव स्ट्रीम
मेश
सिस्टम
MCP टूल्स (grub-crawl.py)
MCP ब्रिज सभी क्षमताओं को किसी भी MCP-संगत होस्ट पर उजागर करता है:
आंतरिक मॉड्यूल
एजेंट कोर (app/agent/)
प्रदाता एडेप्टर (app/agent/providers/)
पॉलिसी गेट्स (app/policy/)
अवलोकनीयता (app/observability/)
API परत
एंटी-डिटेक्शन (app/)
| फ़ाइल | उद्देश्य | स्थिति |
|---|
stealth.py | playwright-stealth पैचेस, ट्रैकर डोमेन ब्लॉकिंग | पूर्ण |
proxy.py | env फ़ॉलबैक के साथ प्रति-अनुरोध प्रॉक्सी समाधान | पूर्ण |
मेश (app/mesh/)
बुनियादी ढाँचा
एजेंट स्टेट मशीन```
INIT -> PLAN -> EXECUTE_TOOL -> OBSERVE -> PLAN -> ... -> RESPOND -> STOP
| |
+-- policy_denied ---------------------->+
+-- max_steps / max_wall_time / max_failures -> STOP
+-- no_op_loop (3x empty) ------------> STOP
+-- blocked (ghost trigger) -----------> GHOST -> OBSERVE
प्रत्येक पुनरावृत्ति पर लागू रोक शर्तें:
- `max_steps` (default: 12)
- `max_wall_time` (default: 90s)
- `max_failures` (default: 3)
- `no_op_loop` (3 लगातार खाली प्रतिक्रियाएँ)
- `policy_denied` (अवरुद्ध उपकरण/डोमेन)
- `completed` (एजेंट टेक्स्ट के साथ प्रतिक्रिया करता है)
## एंटी-डिटेक्शन
तीन एंटी-डिटेक्शन परतें जो एक साथ स्टैक होती हैं। रोकथाम ब्लॉकों को होने से पहले रोकती है। घोस्ट प्रोटोकॉल उन्हें बाद में संभालता है।
### Camoufox Engine
प्लगेबल एंटी-डिटेक्ट ब्राउज़र जिसमें C++-स्तर की फिंगरप्रिंट स्पूफिंग है। कोई मैन्युअल यूज़र-एजेंट ट्रिक्स नहीं — Camoufox ब्राउज़र स्तर पर प्रति संदर्भ यथार्थवादी फिंगरप्रिंट उत्पन्न करता है, जिसमें canvas, WebGL, फ़ॉन्ट्स और navigator प्रॉपर्टीज़ शामिल हैं।```bash
# Switch engine (default: chromium)
BROWSER_ENGINE=camoufox
प्रति-अनुरोध प्रॉक्सी
क्रॉल ट्रैफ़िक को रेज़िडेंशियल, डेटासेंटर, या कस्टम प्रॉक्सी पूल के माध्यम से रूट करें। एनवी-आधारित डिफ़ॉल्ट के साथ प्रति-अनुरोध ओवरराइड। पूर्ण Playwright-संगत प्रॉक्सी कॉन्फ़िगरेशन।```bash
Env-based default
PROXY_SERVER=http://proxy.example.com:10001
PROXY_USERNAME=your_username
PROXY_PASSWORD=your_password
Or per-request
curl -X POST http://localhost:6792/api/crawl
-H "Content-Type: application/json"
-d '{
"url": "https://example.com",
"options": {
"proxy": {
"server": "http://proxy.example.com:10001",
"username": "your_username",
"password": "your_password"
}
}
}'
### गुप्त मोड
ऑप्ट-इन `playwright-stealth` पैच क्रोमियम के लिए (कैमोफॉक्स के लिए छोड़ दिया गया क्योंकि यह उसमें निर्मित है)। 20+ ट्रैकिंग/एनालिटिक्स डोमेन (Google Analytics, DataDome, PerimeterX, आदि) को अवरुद्ध करता है ताकि फिंगरप्रिंट सतह को कम किया जा सके।```bash
STEALTH_ENABLED=true
BLOCK_TRACKING_DOMAINS=true
भूत प्रोटोकॉल
जब क्रॉल परिणाम किसी एंटी-बॉट ब्लॉक (Cloudflare चैलेंज, CAPTCHA,
खाली SPA शेल) का संकेत देता है, तो एजेंट क्लोक मोड पर स्विच कर सकता है:
- Playwright के माध्यम से पूर्ण-पृष्ठ स्क्रीनशॉट लें
- छवि को दृष्टि-सक्षम LLM (Claude Sonnet या GPT-4o) को भेजें
- प्रस्तुत पिक्सल से सामग्री निकालें
- ट्रेस में
render_mode: "ghost" के साथ निकाला गया टेक्स्ट लौटाएं
यह पूरी तरह से DOM-आधारित एंटी-बॉट डिटेक्शन को बायपास करता है।
AGENT_GHOST_ENABLED=true की आवश्यकता है। जब AGENT_GHOST_AUTO_TRIGGER=true होता है, तो पाए गए ब्लॉक पर स्वचालित रूप से ट्रिगर होता है।
मेश
एजेंट एक-दूसरे से बात कर रहे हैं। प्रत्येक Grub इंस्टेंस एक कार्यकर्ता और एक समन्वयक दोनों है। स्थानीय नोड क्लाउड पर ऑफलोड करता है, क्लाउड स्थानीय को प्रतिनिधि कार्य सौंपता है। टूल कॉल पारदर्शी रूप से वायर के पार जाती हैं।```
Node A (local) Node B (cloud)
┌─────────────┐ ┌─────────────┐
│ AgentEngine │ │ AgentEngine │
│ ↓ │ │ ↓ │
│ MeshDispatcher ──── HTTP ────→ MeshDispatcher │
│ ↓ │ │ ↓ │
│ Dispatcher │ │ Dispatcher │
│ ↓ │ │ ↓ │
│ ToolRegistry │ │ ToolRegistry │
└─────────────┘ └─────────────┘
↕ heartbeat (15s) ↕
└────────────────────────────────┘
**यह कैसे काम करता है:**
- **Discovery** — नोड्स seed peer list के माध्यम से जुड़ते हैं, फिर gossip (1-hop) दूसरों के बारे में जानने के लिए
- **Heartbeat** — हर 15 सेकंड में, नोड्स load metrics का आदान-प्रदान करते हैं। 3 मिस = अस्वस्थ। 2 मिनट = हटा दिया गया
- **Routing** — MeshDispatcher सभी नोड्स को load, locality, और affinity के आधार पर स्कोर करता है, फिर tool calls को सबसे अच्छे नोड पर रूट करता है
- **1-hop max** — नोड A → B ही, कभी A → B → C नहीं। Routing loops को रोकता है
- **Local fallback** — यदि remote execution विफल होता है, तो local Dispatcher पर वापस आ जाता है
- **HMAC auth** — सभी mesh traffic एक shared secret (SHA-256, 60s TTL) के साथ signed होता है
### स्थानीय रूप से 2-Node Mesh चलाएं```bash
# Docker Compose (recommended)
./deploy.sh mesh # Linux/Mac
./deploy.ps1 -Target mesh # Windows
# Verify
curl http://localhost:6792/mesh/peers # Node A sees Node B
curl http://localhost:6793/mesh/peers # Node B sees Node A
स्थानीय को Cloud Run से कनेक्ट करें```bash
Deploy to Cloud Run with mesh
./deploy.sh cloudrun latest --mesh-peer http://your-local-ip:6792 --mesh-secret mysecret
Start local node
MESH_ENABLED=true MESH_SECRET=mysecret MESH_PEERS=https://your-cloud-run-url
MESH_ADVERTISE_URL=http://your-local-ip:6792
uvicorn app.main:app --port 6792
### मैन्युअल सेटअप```bash
# Node A
MESH_ENABLED=true MESH_NODE_NAME=local MESH_SECRET=test123 \
MESH_ADVERTISE_URL=http://localhost:6792 \
uvicorn app.main:app --port 6792
# Node B
MESH_ENABLED=true MESH_NODE_NAME=cloud MESH_SECRET=test123 \
MESH_PEERS=http://localhost:6792 \
MESH_ADVERTISE_URL=http://localhost:8081 \
uvicorn app.main:app --port 8081
जब मेश अक्षम होता है (MESH_ENABLED=false, डिफ़ॉल्ट), तो ग्रब सामान्य एकल-नोड क्रॉलर के रूप में शून्य मेश ओवरहेड के साथ काम करता है।
Live Stream
क्रॉलर को रीयल-टाइम में काम करते हुए देखें। गर्म Chromium इंस्टेंस का एक स्थायी पूल WebSocket या MJPEG पर व्यूपोर्ट फ्रेम स्ट्रीम करता है।
WebSocket — कनेक्ट करें और इंटरैक्टिव कमांड भेजें:```javascript
const ws = new WebSocket("ws://localhost:6792/stream/my-session?url=https://example.com");
ws.onmessage = (e) => {
const msg = JSON.parse(e.data);
if (msg.type === "frame") document.getElementById("viewport").src = "data:image/jpeg;base64," + msg.data;
};
// Navigate, click, scroll, type — all over the same socket
ws.send(JSON.stringify({ action: "navigate", url: "https://example.com/pricing" }));
ws.send(JSON.stringify({ action: "click", selector: "#signup-btn" }));
ws.send(JSON.stringify({ action: "scroll", direction: "down" }));
**MJPEG** — इसे `` टैग में डालें, तुरंत वीडियो:```html
<img src="http://localhost:6792/stream/my-session/mjpeg?url=https://example.com" />
BROWSER_STREAM_ENABLED=true आवश्यक है। प्रत्येक Chromium इंस्टेंस लगभग 150-300MB RAM का उपयोग करता है।
त्वरित आरंभ
स्थानीय विकास```bash
git clone
cd grub-crawl
cp .env.example .env
pip install -r requirements.txt
uvicorn app.main:app --reload --host 0.0.0.0 --port 6792
### एजेंट मोड B सक्षम करें```bash
# Add to .env
AGENT_ENABLED=true
OPENAI_API_KEY=sk-...
# or
ANTHROPIC_API_KEY=sk-ant-...
AGENT_PROVIDER=anthropic
एजेंट कार्य सबमिट करें```bash
curl -X POST http://localhost:6792/api/agent/run
-H "Content-Type: application/json"
-d '{
"task": "Find the pricing page on example.com and extract plan details",
"max_steps": 10,
"allowed_domains": ["example.com"]
}'
### Docker```bash
# Single node
./deploy.sh local # or ./deploy.ps1 -Target local
# 2-node mesh
./deploy.sh mesh # or ./deploy.ps1 -Target mesh
# Cloud Run
./deploy.sh cloudrun v1.0.0 # or ./deploy.ps1 -Target cloudrun -Tag v1.0.0
# Cloud Run + mesh (connect to local node)
./deploy.sh cloudrun v1.0.0 --mesh-peer http://your-ip:6792 --mesh-secret mykey
पता लगाने से बचाव (Camoufox + प्रॉक्सी)```bash
Add to .env
BROWSER_ENGINE=camoufox
STEALTH_ENABLED=true
BLOCK_TRACKING_DOMAINS=true
Optional: proxy
PROXY_SERVER=http://proxy.example.com:10001
PROXY_USERNAME=your_username
PROXY_PASSWORD=your_password
### Ghost Protocol (एंटी-बॉट बाईपास)```bash
# Add to .env
AGENT_GHOST_ENABLED=true
curl -X POST http://localhost:6792/api/agent/ghost \
-H "Content-Type: application/json" \
-d '{"url": "https://blocked-site.com"}'
लाइव ब्राउज़र स्ट्रीम```bash
Add to .env
BROWSER_STREAM_ENABLED=true
BROWSER_POOL_SIZE=2
MJPEG (open in browser)
open "http://localhost:6792/stream/demo/mjpeg?url=https://example.com"
## कॉन्फ़िगरेशन
### सर्वर
- `HOST` (डिफ़ॉल्ट: 0.0.0.0)
- `PORT` (डिफ़ॉल्ट: 6792)
- `DEBUG` (डिफ़ॉल्ट: false)
### भंडारण
- `STORAGE_PATH` (डिफ़ॉल्ट: ./storage)
- `RUNNING_IN_CLOUD` (डिफ़ॉल्ट: false)
- `GCS_BUCKET_NAME`
- `GOOGLE_CLOUD_PROJECT`
### प्रमाणीकरण
- `DISABLE_AUTH` (डिफ़ॉल्ट: false)
- `GNOSIS_AUTH_URL` (डिफ़ॉल्ट: http://gnosis-auth:5000)
### ब्राउज़र इंजन
- `BROWSER_ENGINE` — chromium | camoufox (डिफ़ॉल्ट: chromium)
### क्रॉलिंग
- `MAX_CONCURRENT_CRAWLS` (डिफ़ॉल्ट: 5)
- `CRAWL_TIMEOUT` (डिफ़ॉल्ट: 30)
- `ENABLE_JAVASCRIPT` (डिफ़ॉल्ट: true)
- `ENABLE_SCREENSHOTS` (डिफ़ॉल्ट: false)
### प्रॉक्सी
- `PROXY_SERVER` — प्रॉक्सी URL (जैसे http://proxy:10001)
- `PROXY_USERNAME`
- `PROXY_PASSWORD`
- `PROXY_BYPASS` — अल्पविराम से अलग बायपास सूची
### स्टील्थ
- `STEALTH_ENABLED` (डिफ़ॉल्ट: false) — playwright-stealth पैच
- `BLOCK_TRACKING_DOMAINS` (डिफ़ॉल्ट: false) — एनालिटिक्स/ट्रैकिंग अनुरोधों को ब्लॉक करें
### एजेंट (मोड B)
- `AGENT_ENABLED` (डिफ़ॉल्ट: false)
- `AGENT_MAX_STEPS` (डिफ़ॉल्ट: 12)
- `AGENT_MAX_WALL_TIME_MS` (डिफ़ॉल्ट: 90000)
- `AGENT_MAX_FAILURES` (डिफ़ॉल्ट: 3)
- `AGENT_ALLOWED_TOOLS` — अल्पविराम से अलग अनुमति सूची
- `AGENT_ALLOWED_DOMAINS` — अल्पविराम से अलग अनुमति सूची
- `AGENT_BLOCK_PRIVATE_RANGES` (डिफ़ॉल्ट: true)
- `AGENT_REDACT_SECRETS` (डिफ़ॉल्ट: true)
### LLM प्रदाता
- `AGENT_PROVIDER` — openai | anthropic | ollama (डिफ़ॉल्ट: openai)
- `OPENAI_API_KEY`
- `OPENAI_MODEL` (डिफ़ॉल्ट: gpt-4.1-mini)
- `ANTHROPIC_API_KEY`
- `ANTHROPIC_MODEL` (डिफ़ॉल्ट: claude-3-5-sonnet-latest)
- `OLLAMA_BASE_URL` (डिफ़ॉल्ट: http://localhost:11434)
- `OLLAMA_MODEL` (डिफ़ॉल्ट: llama3.1:8b-instruct)
### घोस्ट प्रोटोकॉल
- `AGENT_GHOST_ENABLED` (डिफ़ॉल्ट: false)
- `AGENT_GHOST_AUTO_TRIGGER` (डिफ़ॉल्ट: true)
- `AGENT_GHOST_VISION_PROVIDER` — AGENT_PROVIDER से विरासत में मिलता है
- `AGENT_GHOST_MAX_IMAGE_WIDTH` (डिफ़ॉल्ट: 1280)
### मेश
- `MESH_ENABLED` (डिफ़ॉल्ट: false) — मास्टर स्विच
- `MESH_PEERS` — अल्पविराम से अलग सीड पीयर URL
- `MESH_NODE_NAME` — मानव-पठनीय नाम (डिफ़ॉल्ट: होस्टनाम)
- `MESH_SECRET` — इंटर-नोड प्रमाणीकरण के लिए साझा HMAC रहस्य
- `MESH_ADVERTISE_URL` — URL जिसका उपयोग पीयर इस नोड तक पहुंचने के लिए करते हैं
- `MESH_PREFER_LOCAL` (डिफ़ॉल्ट: true) — स्थानीय निष्पादन की ओर झुकाव
- `MESH_HEARTBEAT_INTERVAL_S` (डिफ़ॉल्ट: 15)
- `MESH_PEER_TIMEOUT_S` (डिफ़ॉल्ट: 45) — इसके बाद अस्वस्थ के रूप में चिह्नित करें
- `MESH_PEER_REMOVE_S` (डिफ़ॉल्ट: 120) — इसके बाद पीयर तालिका से हटाएं
- `MESH_REMOTE_TIMEOUT_MS` (डिफ़ॉल्ट: 35000) — रिमोट टूल कॉल के लिए टाइमआउट
### लाइव स्ट्रीम
- `BROWSER_POOL_SIZE` (डिफ़ॉल्ट: 1)
- `BROWSER_STREAM_ENABLED` (डिफ़ॉल्ट: false)
- `BROWSER_STREAM_QUALITY` (डिफ़ॉल्ट: 25) — JPEG गुणवत्ता 1-100
- `BROWSER_STREAM_MAX_WIDTH` (डिफ़ॉल्ट: 854)
- `BROWSER_STREAM_MAX_LEASE_SECONDS` (डिफ़ॉल्ट: 300)
## प्रतिक्रिया अनुबंध
`POST /api/markdown` लौटाता है:
`success`, `url`, `final_url`, `status_code`, `markdown`, `markdown_plain`, `content`, `render_mode`, `wait_strategy`, `timings_ms`, `blocked`, `block_reason`, `captcha_detected`, `http_error_family`, `body_char_count`, `body_word_count`, `visible_char_count`, `visible_word_count`, `visible_similarity`, `quarantined`, `quarantine_reason`, `policy_flags`, `content_quality`, `extractor_version`, `normalized_url`, `content_hash`
### सामग्री गुणवत्ता
- `blocked` — एंटी-बॉट/कैप्चा/चैलेंज
- `empty` — बहुत कम संकेत
- `minimal` — पतले/त्रुटि पृष्ठ
- `sufficient` — सारांशीकरण के लिए उपयोग योग्य
तब तक सारांश न बनाएं जब तक `content_quality == "sufficient"` न हो।
### प्रॉम्प्ट इंजेक्शन रक्षा
- `quarantined=true` का अर्थ है कि एक्सट्रैक्टर ने निकाली गई सामग्री में इंस्ट्रक्शन-जैसा टेक्स्ट पाया जो पृष्ठ के दृश्यमान रेंडर किए गए टेक्स्ट में मौजूद नहीं था (`.sr-only`/दृष्टिगत रूप से छिपे दुरुपयोग में सामान्य)।
- जब quarantine किया जाता है, तो `content_quality` को `minimal` में डाउनग्रेड किया जाता है, `policy_flags` में `hidden_text_suspected` और `quarantined` शामिल होता है, और `content`/`markdown` आउटपुट खाली कर दिए जाते हैं (fail-closed)।
### त्रुटि प्रारूप```json
{"error": "http_error|validation_error|internal_error", "status": 400, "details": {}}
बेंचमार्क
कॉम्बैट एरीना — Crawl4AI, Firecrawl (सेल्फ-होस्टेड), और Scrapy के खिलाफ आमने-सामने के बेंचमार्क। सभी परीक्षण एक ही मशीन, समान यूआरएल, समान स्थितियों पर चलाए गए। Grub पहले बेसलाइन के रूप में चलता है, शेष एडेप्टर यादृच्छिक क्रम में प्रत्येक के बीच 10 सेकंड के अंतराल के साथ चलाए जाते हैं ताकि दर-सीमित पूर्वाग्रह को रोका जा सके।
एकल-यूआरएल गति (ms, कम बेहतर है)
Grub 4/5 एकल-यूआरएल गति दौड़ जीतता है। मार्कडाउन रूपांतरण मूल Rust इंजन (grub_md) के माध्यम से 0-21ms पर चलता है।
Grub चरण विश्लेषण (सर्वर-साइड ms)
नेविगेशन प्रमुख है; Rust इंजन के कारण अधिकांश पृष्ठों पर मार्कडाउन रूपांतरण एक मिलीसेकंड से कम है।
बैच थ्रूपुट (ms, कम बेहतर है)
Grub 2/3 बैच आकार जीतता है। प्रति-यूआरएल लागत: 163-312ms (Grub) बनाम 255-477ms (अन्य)।
कैसे चलाएं```bash
Start Grub
docker compose up -d
Start Firecrawl (optional)
docker compose -f combat/firecrawl-compose.yaml up -d
Install combat deps
pip install crawl4ai scrapy markdownify tabulate
Run the arena
pytest combat/ -m combat -v
Generate report
python -m combat.report
## विकास की स्थिति
### चरण 1: कोर इंफ्रास्ट्रक्चर ✅
### चरण 2: क्रॉलिंग ✅
### चरण 3: एजेंट मॉड्यूल ✅
- [x] एजेंट कोर — स्टेट मशीन, टाइप्स, एरर (W1)
- [x] एकीकृत टूल कॉन्ट्रैक्ट — टाइमआउट/रीट्री के साथ डिस्पैचर (W2)
- [x] पॉलिसी गेट्स — डोमेन अनुमति-सूची, प्राइवेट-रेंज अस्वीकार, रिडक्शन (W3)
- [x] ऑब्ज़र्वबिलिटी — EventBus, TraceCollector, RunSummary पर्सिस्टेंस (W4)
- [x] API वायरिंग — `/api/agent/run`, `/api/agent/status`, JobType.AGENT_RUN (W5)
- [x] प्रोवाइडर एडेप्टर — OpenAI, Anthropic, Ollama फ़ॉलबैक के साथ (W6)
- [x] कॉन्फ़िग फ़्लैग्स — एजेंट, प्रोवाइडर, घोस्ट, स्ट्रीम सेटिंग्स (W7)
### चरण 4: घोस्ट प्रोटोकॉल ✅
- [x] क्लोक-मोड ट्रिगर डिटेक्शन (W8)
- [x] स्क्रीनशॉट कैप्चर पाइपलाइन (W8)
- [x] Claude/GPT-4o के माध्यम से विज़न एक्सट्रैक्शन (W8)
- [x] इंजन में फ़ॉलबैक चेन (W8)
- [x] बाहरी कॉलर्स के लिए घोस्ट टूल (W8)
- [x] घोस्ट MCP टूल + REST एंडपॉइंट (W8)
### चरण 5: लाइव ब्राउज़र स्ट्रीम ✅
- [x] लीज़/रिटर्न के साथ पर्सिस्टेंट ब्राउज़र पूल (W9)
- [x] CDP स्क्रीनकास्ट रिले (W9)
- [x] इंटरैक्टिव कमांड्स के साथ WebSocket एंडपॉइंट (W9)
- [x] MJPEG फ़ॉलबैक स्ट्रीम (W9)
- [x] स्ट्रीम स्थिति + पूल स्थिति एंडपॉइंट (W9)
### चरण 5.5: एंटी-डिटेक्शन ✅
- [x] कैमोफ़ॉक्स एंटी-डिटेक्ट ब्राउज़र इंजन (W10)
- [x] एनवी फ़ॉलबैक के साथ प्रति-अनुरोध प्रॉक्सी (W10)
- [x] क्रोमियम के लिए स्टील्थ पैच (W10)
- [x] ट्रैकर/विश्लेषण डोमेन ब्लॉकिंग (W10)
- [x] एनथ्रोपिक विज़न फ़ॉर्मेट डिटेक्शन फिक्स (W10)
### चरण 6: मेश कोऑर्डिनेटर ✅
- [x] गॉसिप के साथ पीयर डिस्कवरी (1-हॉप) (W11)
- [x] HMAC-SHA256 इंटर-नोड ऑथ (W11)
- [x] लोड मेट्रिक्स + सीड रीट्री के साथ हार्टबीट लूप (W11)
- [x] MeshDispatcher — पारदर्शी क्रॉस-नोड टूल रूटिंग (W12)
- [x] लोड-आधारित स्कोरिंग लोकैलिटी/एफ़िनिटी बोनस के साथ (W12)
- [x] डिप्लॉय स्क्रिप्ट्स — लोकल, मेश, क्लाउड रन (W12)
- [x] Docker Compose 2-नोड मेश टोपोलॉजी (W12)
- [x] एम्बेडेड लैंडिंग पेज (grub-site) (W12)
### चरण 7: प्रदर्शन + सख्तीकरण
- [x] रस्ट मार्कडाउन इंजन (`grub_md`) — PyO3 नेटिव एक्सटेंशन, सब-ms रूपांतरण
- [x] कॉम्बैट एरेना — Crawl4AI, Firecrawl, Scrapy के विरुद्ध स्वचालित बेंचमार्क
- [x] यूनिट टेस्ट सूट — सभी मॉड्यूल में 176 परीक्षण
- [ ] एरर हैंडलिंग में सुधार
- [ ] निगरानी और अलर्टिंग
पूर्ण आर्किटेक्चर योजना के लिए [MASTER_PLAN.md](https://github.com/deepbluedynamics/grubcrawler/blob/HEAD/MASTER_PLAN.md) देखें।
## लाइसेंस
ग्रब क्रॉलर प्रोजेक्ट लाइसेंस
deepbluedynamics/grubcrawler