@soyaxell09/zenbot-scraper 1.0.13 → 1.1.1

package/src/search/pinterest.js

@@ -64,15 +64,21 @@ export async function pinvid(input, limit = 5) {
   return vids.map((v, i) => ({ index: i + 1, ...v }))
 }
 
-export async function pinsearch(query, limit = 10) {
-  const res = await axios.get(
-    `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(query)}`,
-    { headers: HEADERS, timeout: 15000 }
-  )
-  const $    = cheerio.load(res.data)
-  const seen = new Set()
-  const imgs = []
-
+function extractFromHtml(html) {
+  const $ = cheerio.load(html)
+  const pinIds  = []
+  const seenIds = new Set()
+  $('a[href*="/pin/"]').each((_, el) => {
+    const m = ($(el).attr('href') || '').match(/\/pin\/(\d+)/)
+    if (m && !seenIds.has(m[1])) { seenIds.add(m[1]); pinIds.push(m[1]) }
+  })
+  if (!pinIds.length) {
+    for (const m of html.matchAll(/"id"\s*:\s*"(\d{15,})"/g)) {
+      if (!seenIds.has(m[1])) { seenIds.add(m[1]); pinIds.push(m[1]) }
+    }
+  }
+  const imgList  = []
+  const seenImgs = new Set()
   $('img').each((_, el) => {
     const src    = $(el).attr('src') || ''
     const srcset = $(el).attr('srcset') || ''
@@ -80,22 +86,127 @@ export async function pinsearch(query, limit = 10) {
     for (const s of sources) {
       if (!isValidPin(s)) continue
       const high = toOriginal(s)
-      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+      if (!seenImgs.has(high)) { seenImgs.add(high); imgList.push(high) }
     }
   })
-
   $('[style]').each((_, el) => {
-    const style = $(el).attr('style') || ''
-    const m     = style.match(/url\(['"]?(https:\/\/i\.pinimg\.com[^'")\s]+)['"]?\)/)
+    const m = ($(el).attr('style') || '').match(/url\(['"]?(https:\/\/i\.pinimg\.com[^'")\.s]+)['"]?\)/)
     if (m && isValidPin(m[1])) {
       const high = toOriginal(m[1])
-      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+      if (!seenImgs.has(high)) { seenImgs.add(high); imgList.push(high) }
     }
   })
+  return { pinIds, imgList }
+}
+
+const _pinSearchCache = new Map()
+
+export async function pinsearch(query, limit = 50) {
+  const cacheKey = `search:${query}`
+  let cached = _pinSearchCache.get(cacheKey)
+
+  if (!cached) {
+    cached = { items: [], page: 0, bookmark: null, done: false }
+    _pinSearchCache.set(cacheKey, cached)
+    setTimeout(() => _pinSearchCache.delete(cacheKey), 1000 * 60 * 30)
+  }
+
+  const seenIds = new Set(cached.items.map(i => i.pinId).filter(Boolean))
+
+  while (cached.items.length < limit && !cached.done) {
+    try {
+      let html
+      if (cached.page === 0) {
+        const res = await axios.get(
+          `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(query)}`,
+          { headers: HEADERS, timeout: 15000 }
+        )
+        html = res.data
+        const bmMatch = html.match(/"bookmark"\s*:\s*"([^"]+)"/)
+        cached.bookmark = bmMatch ? bmMatch[1] : null
+      } else if (cached.bookmark) {
+        const res = await axios.get('https://www.pinterest.com/resource/SearchResource/get/', {
+          params: {
+            source_url: `/search/pins/?q=${encodeURIComponent(query)}`,
+            data: JSON.stringify({
+              options: { query, scope: 'pins', bookmarks: [cached.bookmark], page_size: 25 },
+              context: {}
+            }),
+            _: Date.now()
+          },
+          headers: {
+            ...HEADERS,
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Accept': 'application/json',
+            'Referer': `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(query)}`,
+          },
+          timeout: 15000
+        })
+        const apiData = res.data
+        cached.bookmark = apiData?.resource_response?.bookmark || null
+        if (!cached.bookmark) cached.done = true
 
-  const result = imgs.slice(0, limit)
-  if (!result.length) throw new Error('Sin resultados en Pinterest')
-  return result.map((url, i) => ({ index: i + 1, image: url, url }))
+        const newIds = (apiData?.resource_response?.data || [])
+          .filter(p => p.id && !seenIds.has(p.id))
+          .map(p => {
+            seenIds.add(p.id)
+            const img = p.images?.orig?.url || p.images?.['736x']?.url || p.image_signature
+              ? `https://i.pinimg.com/originals/${p.image_signature?.replace(/(..)(..)(..)(.+)/, '$1/$2/$3/$4')}.jpg`
+              : null
+            return img ? { index: cached.items.length + 1, image: img, url: `https://www.pinterest.com/pin/${p.id}/`, pinId: p.id } : null
+          })
+          .filter(Boolean)
+        cached.items.push(...newIds)
+        cached.page++
+        continue
+      } else {
+        cached.done = true
+        break
+      }
+
+      const { pinIds, imgList } = extractFromHtml(html)
+      for (let i = 0; i < imgList.length; i++) {
+        const pid = pinIds[i]
+        if (pid && seenIds.has(pid)) continue
+        if (pid) seenIds.add(pid)
+        cached.items.push({
+          index:  cached.items.length + 1,
+          image:  imgList[i],
+          url:    pid ? `https://www.pinterest.com/pin/${pid}/` : imgList[i],
+          pinId:  pid || null
+        })
+      }
+      cached.page++
+    } catch { cached.done = true; break }
+  }
+
+  if (!cached.items.length) throw new Error('Sin resultados en Pinterest')
+  return cached.items.slice(0, limit)
+}
+
+function extractPinData(html) {
+  const $ = cheerio.load(html)
+  let found = null
+  $('script').each((_, el) => {
+    const txt = $(el).html() || ''
+    const idx = txt.indexOf('"v3GetPinQuery')
+    if (idx !== -1 && !found) {
+      const jsonStart = txt.lastIndexOf('{', idx)
+      let depth = 0, end = -1
+      for (let i = jsonStart; i < txt.length; i++) {
+        if (txt[i] === '{') depth++
+        else if (txt[i] === '}') { depth--; if (depth === 0) { end = i; break } }
+      }
+      if (end !== -1) {
+        try { found = JSON.parse(txt.slice(jsonStart, end + 1)) } catch {}
+      }
+    }
+  })
+  const key = found ? Object.keys(found)[0] : null
+  const pin = key ? found[key]?.data : null
+  if (!pin || found[key]?.__typename === 'PinNotFound') return null
+  return pin
 }
 
 export async function pinimg(input, limit = 5) {
@@ -108,30 +219,60 @@ export async function pinimg(input, limit = 5) {
     const r = await axios.get(input, { headers: HEADERS, maxRedirects: 5, timeout: 10000 })
     resolvedUrl = r.request?.res?.responseUrl || r.config?.url || input
   }
-  const url = resolvedUrl
 
-  const res  = await axios.get(url, { headers: HEADERS, timeout: 15000 })
+  const res  = await axios.get(resolvedUrl, {
+    headers: { ...HEADERS, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36' },
+    timeout: 15000
+  })
   const html = res.data
-  const $    = cheerio.load(html)
-  const seen = new Set()
-  const imgs = []
+  const pin  = extractPinData(html)
 
-  const jsonMatch = html.match(/"orig"\s*:\s*\{"url"\s*:\s*"([^"]+)"/)
-  if (jsonMatch) {
-    const u = jsonMatch[1].replace(/\\u002F/g, '/').replace(/\\\//g, '/')
-    if (u.includes('i.pinimg.com')) { seen.add(u); imgs.push(u) }
-  }
+  const cleanUrl = resolvedUrl.split('?')[0].split('/sent/')[0]
+  const id    = cleanUrl.match(/\/pin\/(\d+)/)?.[1] || ''
 
-  const PIN_IMG_RE = /"url"\s*:\s*"(https:\\?\/\\?\/i\.pinimg\.com[^"]+)"/g
-  const pinMatches = [...html.matchAll(PIN_IMG_RE)]
-  for (const m of pinMatches) {
-    const u = m[1].replace(/\\u002F/g, '/').replace(/\\\//g, '/').replace(/\\/g, '')
-    if (isValidPin(u)) {
-      const high = toOriginal(u)
-      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+  if (pin) {
+    const creator = pin.nativeCreator || pin.closeupAttribution || pin.originPinner || {}
+    const tags    = (pin.pinJoin?.seoBreadcrumbs || []).map(b => b.name).filter(Boolean)
+    const saves   = pin.aggregatedPinData?.aggregatedStats?.saves ?? null
+    const board   = pin.board?.url ? `https://www.pinterest.com${pin.board.url}` : null
+
+    return {
+      id,
+      title:        pin.title || pin.seoTitle || '',
+      description:  pin.description?.trim() || pin.seoAltText || pin.gridDescription?.trim() || '',
+      altText:      pin.seoAltText || '',
+      image:        pin.images_orig?.url || pin.imageLargeUrl || pin.images_736x?.url || '',
+      images: {
+        orig:  pin.images_orig?.url || pin.imageLargeUrl || '',
+        '736': pin.images_736x?.url || '',
+        '474': pin.images_474x?.url || '',
+        '236': pin.images_236x?.url || '',
+        '136': pin.images_136x136?.url || '',
+      },
+      width:         pin.images_474x?.width  || pin.images_736x?.width  || 0,
+      height:        pin.images_474x?.height || pin.images_736x?.height || 0,
+      dominantColor: pin.dominantColor || '',
+      saves:         saves,
+      repins:        pin.repinCount ?? 0,
+      createdAt:     pin.createdAt || '',
+      tags,
+      domain:        pin.domain || '',
+      link:          pin.link   || '',
+      board,
+      creator: {
+        username: creator.username || '',
+        fullName: creator.fullName || creator.full_name || '',
+      },
+      pinner: {
+        username: pin.pinner?.username || '',
+      },
+      url: cleanUrl,
     }
   }
 
+  const $ = cheerio.load(html)
+  const seen = new Set()
+  const imgs = []
   $('img').each((_, el) => {
     const src    = $(el).attr('src') || ''
     const srcset = $(el).attr('srcset') || ''
@@ -142,21 +283,16 @@ export async function pinimg(input, limit = 5) {
       if (!seen.has(high)) { seen.add(high); imgs.push(high) }
     }
   })
-
-  const ogImg   = $('meta[property="og:image"]').attr('content') || ''
-  const ogTitle = $('meta[property="og:title"]').attr('content') || ''
-  const ogDesc  = $('meta[property="og:description"]').attr('content') || ''
-  if (ogImg && !seen.has(ogImg)) imgs.push(ogImg)
-
   const unique = [...new Set(imgs)].filter(Boolean)
   if (!unique.length) throw new Error('No se pudo extraer la imagen del pin')
 
   return {
-    id:          resolvedUrl.match(/\/pin\/(\d+)/)?.[1] || '',
-    title:       ogTitle,
-    description: ogDesc,
-    image:       unique[0],
-    images:      unique,
-    url:         resolvedUrl,
+    id,
+    title: '', description: '', altText: '', image: unique[0],
+    images: { orig: unique[0], '736': '', '474': '', '236': unique[0], '136': '' },
+    width: 0, height: 0, dominantColor: '', saves: null, repins: 0,
+    createdAt: '', tags: [], domain: '', link: '', board: null,
+    creator: { username: '', fullName: '' }, pinner: { username: '' },
+    url: cleanUrl,
   }
 }

package/src/search/spotify.js

@@ -31,7 +31,7 @@ async function searchTracks(query, limit = 5) {
   }))
 }
 
-async function searchAlbums(query, limit = 5) {
+async function searchAlbums(query, limit = 12) {
   const res = await axios.get(
     `https://api.deezer.com/search/album?q=${encodeURIComponent(query)}&limit=${limit}`,
     { headers: HEADERS, timeout: 15000 }

package/src/scrapers/youtubev2.js

@@ -1,131 +0,0 @@
-// Créditos a FG-error
-import axios from 'axios'
-
-const delay = ms => new Promise(r => setTimeout(r, ms))
-
-function parseFileSize(size) {
-  if (!size) return 0
-  const units = { B: 1, KB: 1024, MB: 1024 ** 2, GB: 1024 ** 3, TB: 1024 ** 4 }
-  const match = size.toString().trim().match(/([\d.]+)\s*(B|KB|MB|GB|TB)/i)
-  if (!match) return 0
-  return Math.round(parseFloat(match[1]) * (units[match[2].toUpperCase()] || 1))
-}
-
-function formatFileSize(bytes) {
-  if (!bytes || isNaN(bytes)) return '0 B'
-  const units = ['B', 'KB', 'MB', 'GB', 'TB']
-  let i = 0
-  while (bytes >= 1024 && i < units.length - 1) { bytes /= 1024; i++ }
-  return `${bytes.toFixed(1).replace(/\.0$/, '')} ${units[i]}`
-}
-
-export async function getFileSizeV2(url) {
-  try {
-    const res   = await axios.head(url, { timeout: 10000 })
-    const bytes = parseInt(res.headers['content-length'] || 0)
-    return formatFileSize(bytes)
-  } catch { return '0 B' }
-}
-
-function normalizeYT(url) {
-  try {
-    const u = new URL(url)
-    if (u.hostname.includes('youtu.be')) return url
-    if (u.hostname.includes('youtube.com')) {
-      if (u.pathname.includes('/watch'))   return `https://youtu.be/${u.searchParams.get('v')}`
-      if (u.pathname.includes('/shorts/')) return `https://youtu.be/${u.pathname.split('/shorts/')[1]}`
-      if (u.pathname.includes('/embed/'))  return `https://youtu.be/${u.pathname.split('/embed/')[1]}`
-    }
-    return url
-  } catch { return url }
-}
-
-async function waitForDownload(mediaUrl) {
-  for (let i = 0; i < 15; i++) {
-    try {
-      const { data } = await axios.get(mediaUrl, { timeout: 15000 })
-      if (data?.percent === 'Completed' && data?.fileUrl && data.fileUrl !== 'In Processing...')
-        return data.fileUrl
-    } catch {}
-    await delay(4000)
-  }
-  throw new Error('No se pudo generar el enlace de descarga')
-}
-
-async function fetchYtdownto(url) {
-  const { data } = await axios.post(
-    'https://app.ytdown.to/proxy.php',
-    new URLSearchParams({ url }).toString(),
-    {
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      timeout: 20000,
-    }
-  )
-  const api = data?.api
-  if (!api)                   throw new Error('No se pudo obtener información del video')
-  if (api.status === 'ERROR') throw new Error(api.message)
-
-  const qualities = (api.mediaItems || []).map((v, i) => {
-    const match = v?.mediaUrl?.match(/(\d+)p|(\d+)k/)
-    const res   = match ? match[0] : v.mediaQuality
-    return {
-      id:       i + 1,
-      type:     v.type,
-      quality:  res,
-      label:    `${v.mediaExtension?.toUpperCase()} - ${v.mediaQuality}`,
-      size:     v.mediaFileSize,
-      sizeB:    parseFileSize(v.mediaFileSize),
-      mediaUrl: v.mediaUrl,
-      duration: v.mediaDuration,
-    }
-  })
-
-  return { api, qualities }
-}
-
-export async function ytDownloadV2(url, type = 'video', quality = '360p') {
-  url = normalizeYT(url)
-
-  const { api, qualities } = await fetchYtdownto(url)
-
-  const isAudio  = type === 'mp3' || type === 'audio'
-  const targetQ  = quality.toLowerCase()
-
-  const filtered = isAudio
-    ? qualities.filter(v => v.type === 'audio' || v.quality?.includes('k'))
-    : qualities.filter(v => v.type === 'video' || v.quality?.includes('p'))
-
-  const selected = filtered.find(v => v.quality?.toLowerCase() === targetQ) || filtered[0]
-
-  if (!selected) {
-    const disponibles = qualities.map(v => v.quality).filter(Boolean).join(', ')
-    throw new Error(`Calidad ${quality} no disponible. Disponibles: ${disponibles}`)
-  }
-
-  const dlUrl = await waitForDownload(selected.mediaUrl)
-
-  return {
-    title:    api.title,
-    uploader: api.userInfo?.name || '',
-    views:    api.mediaStats?.viewsCount || '',
-    thumb:    api.imagePreviewUrl || '',
-    type:     isAudio ? 'audio' : 'video',
-    quality:  selected.quality,
-    size:     selected.size,
-    sizeB:    selected.sizeB,
-    duration: selected.duration,
-    url:      dlUrl,
-  }
-}
-
-export async function ytInfoV2(url) {
-  url = normalizeYT(url)
-  const { api, qualities } = await fetchYtdownto(url)
-  return {
-    title:    api.title,
-    uploader: api.userInfo?.name || '',
-    views:    api.mediaStats?.viewsCount || '',
-    thumb:    api.imagePreviewUrl || '',
-    qualities,
-  }
-}