feat(providers): switch blinkit to unauthenticated Buyhatke endpoint with auth_key, fix zepto fallback

providers/blinkit.py

@@ -7,14 +7,47 @@ logger = logging.getLogger("qc.blinkit")
 
 class BlinkitProvider(BaseProvider):
     platform_name = "blinkit"
+    REQ_KEY = "c0e6868e-1180-400c-be51-f473479f1f0a"  # Buyhatke/Comparify unauthenticated constant (blinkit-mcp)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._auth_key = None
+        self._device_id = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+        self._session_uuid = "11111111-2222-3333-4444-555555555555"
+
+    async def _ensure_auth_key(self) -> str:
+        if self._auth_key:
+            return self._auth_key
+        try:
+            async with AsyncSession(impersonate="chrome124") as s:
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
+                    "app_client": "consumer_web",
+                    "platform": "desktop_web",
+                    "req_key": self.REQ_KEY,
+                    "Accept": "*/*",
+                }
+                resp = await s.get("https://blinkit.com/v2/accounts/auth_key/", headers=headers, timeout=8)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    self._auth_key = data.get("auth_key") or data.get("authKey")
+                    return self._auth_key or ""
+        except Exception as e:
+            logger.warning(f"[Blinkit] auth_key fetch failed: {e}")
+        return ""
 
     def _get_headers(self, lat: float, lon: float) -> dict:
         return {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36",
             "app_client": "consumer_web",
+            "platform": "desktop_web",
+            "web_app_version": "1008010016",
+            "rn_bundle_version": "1009003012",
             "lat": f"{lat:.6f}",
             "lon": f"{lon:.6f}",
-            "Accept": "application/json, text/plain, */*",
+            "device_id": self._device_id,
+            "session_uuid": self._session_uuid,
+            "Accept": "*/*",
             "Accept-Language": "en-US,en;q=0.9",
             "Origin": "https://blinkit.com",
             "Referer": "https://blinkit.com/",
@@ -56,54 +89,84 @@ class BlinkitProvider(BaseProvider):
         lon: float,
         pincode: Optional[str] = None
     ) -> List[RawProduct]:
+        # Buyhatke/Comparify use POST /v1/layout/search with auth_key — unauthenticated, no OTP
+        auth_key = await self._ensure_auth_key()
         headers = self._get_headers(lat, lon)
-        url = f"https://blinkit.com/v1/search/products?q={query}&start=0&size=20"
+        if auth_key:
+            headers["auth_key"] = auth_key
+        # Use Buyhatke-style endpoint: POST /v1/layout/search
+        url = f"https://blinkit.com/v1/layout/search?q={query}&search_type=type_to_search"
         products: List[RawProduct] = []
 
         async with self.semaphore:
             try:
                 async with AsyncSession(impersonate="chrome124") as s:
-                    resp = await s.get(url, headers=headers, timeout=10)
+                    # Blinkit expects POST with JSON body {applied_filters:null, sort:"", previous_search_query}
+                    resp = await s.post(url, headers=headers, json={"applied_filters": None, "sort": "", "previous_search_query": query}, timeout=10)
                     if resp.status_code != 200:
                         logger.warning(f"[Blinkit] Search status={resp.status_code}")
                         return products
 
                     data = resp.json()
-                    items = (
-                        data.get("products", [])
-                        or data.get("objects", [])
-                        or data.get("items", [])
-                    )
+                    # Server-driven UI tree — extract via walk, dedupe, filter by query
+                    raw_items = []
+                    def walk(node):
+                        if not isinstance(node, dict):
+                            return
+                        if "product_id" in node and "price" in node:
+                            raw_items.append(node)
+                        for v in node.values():
+                            if isinstance(v, dict):
+                                walk(v)
+                            elif isinstance(v, list):
+                                for el in v:
+                                    walk(el)
+                    walk(data)
+                    if not raw_items:
+                        raw_items = data.get("products", []) or data.get("objects", []) or data.get("items", [])
+                    # Dedupe by product_id
+                    seen = set()
+                    items = []
+                    for it in raw_items:
+                        pid = str(it.get("product_id") or it.get("id") or "")
+                        if pid in seen:
+                            continue
+                        seen.add(pid)
+                        items.append(it)
+                        if len(items) >= 20:
+                            break
 
                     for item in items:
-                        name = item.get("name") or item.get("title") or item.get("product_name")
+                        name = item.get("name") or item.get("title") or item.get("product_name") or item.get("display_name")
                         if not name:
                             continue
 
-                        price = float(item.get("price") or item.get("selling_price") or 0)
-                        mrp = float(item.get("mrp") or price)
+                        price = float(item.get("price") or item.get("selling_price") or item.get("offer_price") or 0)
+                        mrp = float(item.get("mrp") or item.get("store_price") or price)
                         if price <= 0:
                             continue
 
                         discount = int(round(((mrp - price) / mrp) * 100)) if mrp > price else 0
 
-                        images = item.get("images") or item.get("image_url") or []
+                        images = item.get("images") or item.get("image_url") or item.get("imageUrl") or []
                         img_url = images[0] if isinstance(images, list) and images else (images if isinstance(images, str) else None)
+                        if isinstance(img_url, dict):
+                            img_url = img_url.get("url") or img_url.get("image_url")
 
                         pid = str(item.get("product_id") or item.get("id") or name)
                         brand = item.get("brand") or item.get("brand_name")
-                        unit = item.get("unit") or item.get("pack_size") or item.get("weight")
+                        unit = item.get("unit") or item.get("pack_size") or item.get("weight") or item.get("variant")
 
                         products.append(RawProduct(
                             platform=self.platform_name,
                             product_id=pid,
                             name=name.strip(),
                             brand=brand,
-                            pack_size=unit,
+                            pack_size=str(unit) if unit else None,
                             price=price,
                             mrp=mrp,
                             discount_percentage=discount,
-                            available=item.get("inventory", 1) > 0 if "inventory" in item else True,
+                            available=item.get("inventory", 1) > 0 if "inventory" in item else item.get("in_stock", True),
                             image_url=img_url,
                             deeplink=f"https://blinkit.com/s/?q={query}",
                             eta_minutes=12

providers/zepto.py

@@ -66,15 +66,27 @@ class ZeptoProvider(BaseProvider):
         if store_id:
             headers["x-store-id"] = str(store_id)
 
-        url = f"https://api.zeptonow.com/api/v1/search?query={query}&pageNumber=1&mode=SEARCH"
+        # Try primary host, fallback to www host (api. DNS sometimes fails locally)
+        urls = [
+            f"https://api.zeptonow.com/api/v1/search?query={query}&pageNumber=1&mode=SEARCH",
+            f"https://www.zeptonow.com/api/v1/search?query={query}&pageNumber=1&mode=SEARCH",
+        ]
         products: List[RawProduct] = []
 
         async with self.semaphore:
             try:
                 async with AsyncSession(impersonate="chrome124") as s:
-                    resp = await s.get(url, headers=headers, timeout=10)
-                    if resp.status_code != 200:
-                        logger.warning(f"[Zepto] Search failed status={resp.status_code}")
+                    resp = None
+                    for u in urls:
+                        try:
+                            resp = await s.get(u, headers=headers, timeout=10)
+                            if resp.status_code == 200:
+                                url = u
+                                break
+                        except Exception:
+                            continue
+                    if resp is None or resp.status_code != 200:
+                        logger.warning(f"[Zepto] Search failed status={resp.status_code if resp else 'no response'}")
                         return products
 
                     data = resp.json()