@soyaxell09/zenbot-scraper 1.0.13 → 1.1.0

package/src/scrapers/youtube.js

@@ -1,137 +1,183 @@
-/*
- * © Created by AxelDev09 🔥
- * GitHub: https://github.com/AxelDev09
- * Instagram: @axeldev09
- * Deja los créditos we 🗣️
- */
+// Parchado y modificado por AxelDev09
+// scraper creado por FG-ERROR
 
 import axios from 'axios'
-import ytdl from '@distube/ytdl-core'
 
-const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1'
-let _config = null
+const delay = ms => new Promise(r => setTimeout(r, ms))
 
-async function getConfig() {
-  if (_config) return _config
-  const res = await axios.get('https://www.youtube.com/', {
-    headers: {
-      'User-Agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
-      'Accept-Language': 'en-US,en;q=0.9',
-      'Accept':          'text/html,application/xhtml+xml',
-    },
-    timeout: 15000,
-  })
-  const html          = res.data
-  const key           = html.match(/"INNERTUBE_API_KEY"\s*:\s*"([^"]+)"/)?.[1] || 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM394'
-  const visitorData   = html.match(/"visitorData"\s*:\s*"([^"]+)"/)?.[1] || ''
-  const clientVersion = html.match(/"clientVersion"\s*:\s*"([^"]+)"/)?.[1] || '2.20240101.00.00'
-  _config = { key, visitorData, clientVersion }
-  return _config
+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 parseVideoId(url) {
-  const patterns = [
-    /(?:v=|youtu\.be\/|shorts\/)([a-zA-Z0-9_-]{11})/,
-    /^([a-zA-Z0-9_-]{11})$/,
-  ]
-  for (const p of patterns) {
-    const m = url.match(p)
-    if (m) return m[1]
-  }
-  return null
+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 ytInfo(url) {
-  const id = parseVideoId(url)
-  if (!id) throw new Error('URL/ID de YouTube inválido')
-
-  const info = await ytdl.getInfo(`https://www.youtube.com/watch?v=${id}`)
-  const vd   = info.videoDetails
-  const formats = info.formats
-    .filter(f => f.url)
-    .map(f => ({
-      itag:      f.itag,
-      url:       f.url,
-      mimeType:  f.mimeType || '',
-      quality:   f.qualityLabel || f.quality || '',
-      bitrate:   f.bitrate || f.averageBitrate || 0,
-      width:     f.width  || 0,
-      height:    f.height || 0,
-      fps:       f.fps    || 0,
-      hasVideo:  !!f.hasVideo,
-      hasAudio:  !!f.hasAudio,
-      container: f.container || '',
-      codecs:    f.codecs   || '',
-    }))
+export async function getFileSize(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' }
+}
 
-  return {
-    id,
-    title:       vd.title || '',
-    author:      vd.author?.name || vd.ownerChannelName || '',
-    channelId:   vd.channelId || '',
-    duration:    Number(vd.lengthSeconds || 0),
-    views:       Number(vd.viewCount || 0),
-    thumbnail:   vd.thumbnails?.at(-1)?.url || '',
-    description: vd.description?.slice(0, 300) || '',
-    isLive:      vd.isLiveContent || false,
-    formats,
-  }
+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 }
 }
 
-export async function ytDownload(url, type = 'video', quality = '360') {
-  const id   = parseVideoId(url)
-  if (!id) throw new Error('URL de YouTube inválida')
+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')
+}
 
-  const info    = await ytInfo(id)
-  const formats = info.formats
+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)
 
-  if (type === 'mp3' || type === 'audio') {
-    const audioFormats = formats
-      .filter(f => f.hasAudio && !f.hasVideo)
-      .sort((a, b) => b.bitrate - a.bitrate)
-    if (!audioFormats.length) throw new Error('Sin formatos de audio disponibles')
-    const best = audioFormats[0]
+  const qualities = (api.mediaItems || []).map((v, i) => {
+    const match = v?.mediaUrl?.match(/(\d+)p|(\d+)k/)
+    const res   = match ? match[0] : v.mediaQuality
     return {
-      type:      'audio',
-      url:       best.url,
-      mimeType:  best.mimeType,
-      bitrate:   best.bitrate,
-      duration:  info.duration,
-      title:     info.title,
-      author:    info.author,
-      thumbnail: info.thumbnail,
+      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 ytDownload(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'))
+
+  if (!filtered.length) {
+    const disponibles = qualities.map(v => v.quality).filter(Boolean).join(', ')
+    throw new Error(`Calidad ${quality} no disponible. Disponibles: ${disponibles}`)
   }
 
-  const q            = parseInt(quality)
-  const videoFormats = formats
-    .filter(f => f.hasVideo && f.hasAudio)
-    .sort((a, b) => b.height - a.height)
-
-  if (!videoFormats.length) {
-    const videoOnly = formats
-      .filter(f => f.hasVideo && !f.hasAudio)
-      .sort((a, b) => b.height - a.height)
-    if (!videoOnly.length) throw new Error('Sin formatos de video disponibles')
-    const best = videoOnly.find(f => f.height <= q) || videoOnly[0]
-    return {
-      type: 'video', url: best.url, mimeType: best.mimeType,
-      quality: best.quality, width: best.width, height: best.height,
-      fps: best.fps, title: info.title, author: info.author,
-      thumbnail: info.thumbnail, duration: info.duration,
-      note: 'solo_video_sin_audio',
+  let selected
+  if (isAudio) {
+    const mp3s = filtered.filter(v => v.label?.toLowerCase().includes('mp3'))
+    const pool = mp3s.length ? mp3s : filtered
+    const exact = pool.find(v => v.quality?.toLowerCase() === targetQ)
+    if (exact) {
+      selected = exact
+    } else {
+      selected = pool.sort((a, b) => {
+        const qa = parseInt(a.quality) || 0
+        const qb = parseInt(b.quality) || 0
+        return qb - qa
+      })[0]
     }
+  } else {
+    selected = filtered.find(v => v.quality?.toLowerCase() === targetQ) || filtered[0]
   }
 
-  const best = videoFormats.find(f => f.height <= q) || videoFormats[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 {
-    type: 'video', url: best.url, mimeType: best.mimeType,
-    quality: best.quality, width: best.width, height: best.height,
-    fps: best.fps, title: info.title, author: info.author,
-    thumbnail: info.thumbnail, duration: info.duration,
+    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 ytInfo(url) {
+  url = normalizeYT(url)
+  const { api, qualities } = await fetchYtdownto(url)
+  const duration = qualities[0]?.duration || ''
+  const id = url.match(/youtu\.be\/([a-zA-Z0-9_-]{11})/)?.[1] || ''
+  return {
+    id,
+    title:    api.title,
+    uploader: api.userInfo?.name || '',
+    views:    api.mediaStats?.viewsCount || '',
+    thumb:    api.imagePreviewUrl || '',
+    duration,
+    qualities,
+  }
+}
+
+const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1'
+let _config = null
+
+async function getConfig() {
+  if (_config) return _config
+  const res = await axios.get('https://www.youtube.com/', {
+    headers: {
+      'User-Agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Accept':          'text/html,application/xhtml+xml',
+    },
+    timeout: 15000,
+  })
+  const html          = res.data
+  const key           = html.match(/"INNERTUBE_API_KEY"\s*:\s*"([^"]+)"/)?.[1] || 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM394'
+  const visitorData   = html.match(/"visitorData"\s*:\s*"([^"]+)"/)?.[1] || ''
+  const clientVersion = html.match(/"clientVersion"\s*:\s*"([^"]+)"/)?.[1] || '2.20240101.00.00'
+  _config = { key, visitorData, clientVersion }
+  return _config
+}
+
 export async function ytSearch(query, limit = 5) {
   const cfg = await getConfig()
   const res = await axios.post(
@@ -149,11 +195,11 @@ export async function ytSearch(query, limit = 5) {
     },
     {
       headers: {
-        'User-Agent':              'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
-        'X-YouTube-Client-Name':   '1',
+        'User-Agent':               'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+        'X-YouTube-Client-Name':    '1',
         'X-YouTube-Client-Version': cfg.clientVersion,
-        'Content-Type':            'application/json',
-        'X-Goog-Visitor-Id':       cfg.visitorData,
+        'Content-Type':             'application/json',
+        'X-Goog-Visitor-Id':        cfg.visitorData,
       },
       timeout: 15000,
     }

package/src/search/giphy.js

@@ -13,24 +13,79 @@ const HEADERS = {
 
 const TENOR_KEY = 'AIzaSyAyimkuYQYF_FXVALexPuGQctUWRURdCYQ'
 
+function mapItem(g) {
+  return {
+    id:      g.id,
+    title:   g.title || g.content_description || '',
+    url:     g.itemurl || '',
+    gif:     g.media_formats?.gif?.url      || g.media_formats?.mediumgif?.url || '',
+    preview: g.media_formats?.nanogif?.url  || g.media_formats?.tinygif?.url  || '',
+    mp4:     g.media_formats?.mp4?.url      || g.media_formats?.loopedmp4?.url || '',
+    width:   g.media_formats?.gif?.dims?.[0] || 0,
+    height:  g.media_formats?.gif?.dims?.[1] || 0,
+  }
+}
+
+const _gifCache = new Map()
+
 export async function giphy(query, limit = 5, type = 'search') {
   const endpoint = type === 'trending'
     ? `https://tenor.googleapis.com/v2/featured?key=${TENOR_KEY}&limit=${limit}&media_filter=gif`
-    : `https://tenor.googleapis.com/v2/search?q=${encodeURIComponent(query)}&key=${TENOR_KEY}&limit=${limit}&media_filter=gif`
+    : `https://tenor.googleapis.com/v2/search?q=${encodeURIComponent(query)}&key=${TENOR_KEY}&limit=${limit}&media_filter=gif,mp4`
 
   const res  = await axios.get(endpoint, { headers: HEADERS, timeout: 15000 })
   const data = res.data?.results || []
-
   if (!data.length) throw new Error('Sin resultados en Tenor')
+  return data.map(mapItem)
+}
 
-  return data.map(g => ({
-    id:      g.id,
-    title:   g.title || g.content_description || '',
-    url:     g.itemurl || '',
-    gif:     g.media_formats?.gif?.url     || g.media_formats?.mediumgif?.url || '',
-    preview: g.media_formats?.nanogif?.url || g.media_formats?.tinygif?.url  || '',
-    mp4:     g.media_formats?.mp4?.url     || g.media_formats?.loopedmp4?.url || '',
-    width:   g.media_formats?.gif?.dims?.[0] || 0,
-    height:  g.media_formats?.gif?.dims?.[1] || 0,
-  }))
+export async function gifSearch(query) {
+  const cacheKey = `gif:${query}`
+  let cached = _gifCache.get(cacheKey)
+  if (!cached) {
+    cached = { items: [], next: null, done: false }
+    _gifCache.set(cacheKey, cached)
+    setTimeout(() => _gifCache.delete(cacheKey), 1000 * 60 * 20)
+  }
+  return cached
+}
+
+export async function gifNext(query) {
+  const cached = await gifSearch(query)
+  if (cached.done && cached.items.length === 0) throw new Error('Sin resultados')
+
+  if (!cached.done) {
+    const params = {
+      q:            query,
+      key:          TENOR_KEY,
+      limit:        20,
+      media_filter: 'gif',
+    }
+    if (cached.next) params.pos = cached.next
+    params.media_filter = 'gif,mp4'
+
+    const res  = await axios.get('https://tenor.googleapis.com/v2/search', { params, headers: HEADERS, timeout: 15000 })
+    const data = res.data?.results || []
+    cached.next = res.data?.next || null
+    if (!cached.next || !data.length) cached.done = true
+    cached.items.push(...data.map(mapItem))
+  }
+
+  if (!cached.items.length) throw new Error('Sin resultados')
+
+  const item = cached.items.shift()
+  return item
+}
+
+export async function giphyBuffer(query) {
+  const item = await gifNext(query)
+  const url  = item.mp4 || item.gif
+  if (!url) throw new Error('Sin URL de descarga')
+  const res  = await axios.get(url, { responseType: 'arraybuffer', headers: HEADERS, timeout: 20000 })
+  return {
+    buffer:   Buffer.from(res.data),
+    mimetype: item.mp4 ? 'video/mp4' : 'image/gif',
+    title:    item.title,
+    url,
+  }
 }

package/src/search/index.js

@@ -5,11 +5,11 @@
  * Deja los créditos we 🗣️
  */
 
-export { ytSearch }                  from './youtube.js'
-export { googleSearch }              from './google.js'
-export { spotify }                   from './spotify.js'
-export { giphy }                     from './giphy.js'
-export { pinsearch, pinimg, pinvid } from './pinterest.js'
-export { stickerSearch }             from './stickersearch.js'
-export { animeImage }                from './anime.js'
-export { wallpaperSearch }           from './wallpaper.js'
+export { ytSearch }                          from './youtube.js'
+export { googleSearch }                      from './google.js'
+export { spotify }                           from './spotify.js'
+export { giphy, gifNext, giphyBuffer }       from './giphy.js'
+export { pinsearch, pinimg, pinvid }         from './pinterest.js'
+export { stickerSearch }                     from './stickersearch.js'
+export { animeImage }                        from './anime.js'
+export { wallpaperSearch }                   from './wallpaper.js'