@soyaxell09/zenbot-scraper 1.0.0

package/src/scrapers/facebook.js

@@ -0,0 +1,201 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+ 
+import axios from 'axios'
+
+const HEADERS_DESKTOP = {
+  'User-Agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+  'Accept':          'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+  'Accept-Language': 'en-US,en;q=0.9',
+  'Sec-Fetch-Mode':  'navigate',
+}
+
+const HEADERS_MOBILE = {
+  'User-Agent':      'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 Mobile/15E148',
+  'Accept':          'text/html,application/xhtml+xml',
+  'Accept-Language': 'en-US,en;q=0.9',
+}
+
+function cleanUrl(url) {
+  try {
+    const u = new URL(url)
+    if (u.hostname.includes('fb.watch')) return url
+    u.search = ''
+    return u.toString()
+  } catch { return url }
+}
+
+async function resolveShortUrl(url) {
+  if (!url.includes('fb.watch') && !url.includes('fb.com')) return url
+  const res = await axios.get(url, { headers: HEADERS_DESKTOP, maxRedirects: 5, timeout: 10000 })
+  return res.request?.res?.responseUrl || url
+}
+
+function extractVideoUrls(html) {
+  const results = { hd: null, sd: null, thumb: null, title: '' }
+
+  const unescape = s => s
+    .replace(/\\u0025/g, '%')
+    .replace(/\\u002F/g, '/')
+    .replace(/\\\//g, '/')
+    .replace(/\\"/g, '"')
+    .replace(/\\u0026/g, '&')
+    .replace(/\\u003C/g, '<')
+    .replace(/\\u003E/g, '>')
+
+  const hdPatterns = [
+    /"browser_native_hd_url"\s*:\s*"([^"]+)"/,
+    /"hd_src"\s*:\s*"([^"]+)"/,
+    /hd_src\s*:\s*"([^"]+)"/,
+    /"hdUrl"\s*:\s*"([^"]+)"/,
+    /"playable_url_quality_hd"\s*:\s*"([^"]+)"/,
+    /"videoUrl"\s*:\s*"([^"]+)"/,
+    /sd_src_no_ratelimit\s*:\s*"([^"]+)"/,
+  ]
+  for (const p of hdPatterns) {
+    const m = html.match(p)
+    if (m) { results.hd = unescape(m[1]); break }
+  }
+
+  const sdPatterns = [
+    /"browser_native_sd_url"\s*:\s*"([^"]+)"/,
+    /"sd_src"\s*:\s*"([^"]+)"/,
+    /sd_src\s*:\s*"([^"]+)"/,
+    /"sdUrl"\s*:\s*"([^"]+)"/,
+    /"playable_url"\s*:\s*"([^"]+)"/,
+    /"progressive_url"\s*:\s*"([^"]+)"/,
+  ]
+  for (const p of sdPatterns) {
+    const m = html.match(p)
+    if (m) { results.sd = unescape(m[1]); break }
+  }
+
+  const thumbPatterns = [
+    /"thumbnailImage"\s*:\s*\{"uri"\s*:\s*"([^"]+)"/,
+    /og:image"\s+content="([^"]+)"/,
+    /"preferred_thumbnail"\s*:\s*\{"image"\s*:\s*\{"uri"\s*:\s*"([^"]+)"/,
+  ]
+  for (const p of thumbPatterns) {
+    const m = html.match(p)
+    if (m) { results.thumb = unescape(m[1]); break }
+  }
+
+  const titlePatterns = [
+    /<title>([^<]+)<\/title>/,
+    /"story_name"\s*:\s*"([^"]+)"/,
+    /"title"\s*:\s*\{"text"\s*:\s*"([^"]+)"/,
+  ]
+  for (const p of titlePatterns) {
+    const m = html.match(p)
+    if (m) {
+      results.title = m[1].replace(/&#039;/g, "'").replace(/&amp;/g, '&')
+      break
+    }
+  }
+
+  return results
+}
+
+function extractVideoId(url) {
+  const patterns = [
+    /\/videos\/(\d+)/,
+    /\/video\/(\d+)/,
+    /v=(\d+)/,
+    /story_fbid=(\d+)/,
+    /\/reel\/(\d+)/,
+    /\/(\d{10,})/,
+  ]
+  for (const p of patterns) {
+    const m = url.match(p)
+    if (m) return m[1]
+  }
+  return null
+}
+
+async function tryMobilePage(url) {
+  const murl = url.replace('www.facebook.com', 'm.facebook.com')
+  const res  = await axios.get(murl, { headers: HEADERS_MOBILE, timeout: 15000 })
+  return extractVideoUrls(res.data)
+}
+
+async function tryDesktopPage(url) {
+  const res = await axios.get(url, { headers: HEADERS_DESKTOP, timeout: 15000 })
+  return extractVideoUrls(res.data)
+}
+
+async function tryGraphQL(videoId) {
+  const queries = [
+    { doc_id: '10154874153461729', vars: { videoID: videoId } },
+    { doc_id: '6861055570608956',  vars: { UFICommentID: videoId, UFIFeedbackID: videoId } },
+    { doc_id: '2443510449042541',  vars: { videoID: videoId } },
+  ]
+
+  for (const q of queries) {
+    try {
+      const res = await axios.post(
+        'https://www.facebook.com/api/graphql/',
+        new URLSearchParams({
+          variables:         JSON.stringify(q.vars),
+          doc_id:            q.doc_id,
+          server_timestamps: 'true',
+        }),
+        {
+          headers: {
+            ...HEADERS_DESKTOP,
+            'Content-Type':      'application/x-www-form-urlencoded',
+            'X-FB-Friendly-Name':'VideoPlayerQuery',
+          },
+          timeout: 15000,
+        }
+      )
+      const d    = res.data
+      const node = d?.data?.video || d?.data?.node || d?.data?.mediaset
+      const hd   = node?.playable_url_quality_hd || node?.browser_native_hd_url
+      const sd   = node?.playable_url            || node?.browser_native_sd_url
+      if (hd || sd) return { hd: hd || null, sd: sd || null, thumb: node?.thumbnailImage?.uri || '', title: node?.name || node?.title?.text || '' }
+    } catch {}
+  }
+  return null
+}
+
+export async function fbDownload(url) {
+  if (!url.includes('facebook.com') && !url.includes('fb.watch') && !url.includes('fb.com'))
+    throw new Error('URL de Facebook inválida')
+
+  const resolved = await resolveShortUrl(url)
+  const clean    = cleanUrl(resolved)
+  const videoId  = extractVideoId(clean)
+  const errors   = []
+
+  try {
+    const parsed = await tryMobilePage(clean)
+    if (parsed.hd || parsed.sd) {
+      return { videoId: videoId || '', title: parsed.title, hd: parsed.hd, sd: parsed.sd, thumb: parsed.thumb, source: 'mobile' }
+    }
+    errors.push('mobile: sin urls')
+  } catch (e) { errors.push('mobile: ' + e.message) }
+
+  try {
+    const parsed = await tryDesktopPage(clean)
+    if (parsed.hd || parsed.sd) {
+      return { videoId: videoId || '', title: parsed.title, hd: parsed.hd, sd: parsed.sd, thumb: parsed.thumb, source: 'desktop' }
+    }
+    errors.push('desktop: sin urls')
+  } catch (e) { errors.push('desktop: ' + e.message) }
+
+  if (videoId) {
+    try {
+      const data = await tryGraphQL(videoId)
+      if (data?.hd || data?.sd) {
+        return { videoId, title: data.title, hd: data.hd, sd: data.sd, thumb: data.thumb, source: 'graphql' }
+      }
+      errors.push('graphql: sin urls')
+    } catch (e) { errors.push('graphql: ' + e.message) }
+  }
+
+  throw new Error('No se pudo descargar. Errores: ' + errors.join(' | '))
+}

package/src/scrapers/github.js

@@ -0,0 +1,156 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+  'Accept':     'application/vnd.github.v3+json',
+}
+
+function parseRepo(input) {
+  const m = input.match(/github\.com\/([^/]+\/[^/]+)/)
+  if (m) return m[1].replace(/\.git$/, '')
+  if (/^[^/]+\/[^/]+$/.test(input)) return input
+  return null
+}
+
+async function get(url) {
+  const res = await axios.get(url, { headers: HEADERS, timeout: 15000 })
+  return res.data
+}
+
+export async function githubInfo(repo) {
+  const r = parseRepo(repo)
+  if (!r) throw new Error('Repo inválido. Usá owner/repo o URL de GitHub')
+
+  const data = await get(`https://api.github.com/repos/${r}`)
+
+  return {
+    name:        data.name,
+    fullName:    data.full_name,
+    description: data.description || '',
+    url:         data.html_url,
+    stars:       data.stargazers_count,
+    forks:       data.forks_count,
+    watchers:    data.watchers_count,
+    issues:      data.open_issues_count,
+    language:    data.language || '',
+    license:     data.license?.name || '',
+    topics:      data.topics || [],
+    private:     data.private,
+    fork:        data.fork,
+    createdAt:   data.created_at,
+    updatedAt:   data.updated_at,
+    pushedAt:    data.pushed_at,
+    size:        data.size,
+    defaultBranch: data.default_branch,
+    owner: {
+      login:  data.owner?.login || '',
+      avatar: data.owner?.avatar_url || '',
+      url:    data.owner?.html_url || '',
+      type:   data.owner?.type || '',
+    },
+    cloneUrl: data.clone_url,
+    sshUrl:   data.ssh_url,
+    zipUrl:   `https://github.com/${r}/archive/refs/heads/${data.default_branch}.zip`,
+  }
+}
+
+export async function githubRelease(repo) {
+  const r = parseRepo(repo)
+  if (!r) throw new Error('Repo inválido')
+
+  const data = await get(`https://api.github.com/repos/${r}/releases/latest`)
+
+  return {
+    tag:         data.tag_name,
+    name:        data.name || data.tag_name,
+    body:        data.body || '',
+    draft:       data.draft,
+    prerelease:  data.prerelease,
+    createdAt:   data.created_at,
+    publishedAt: data.published_at,
+    url:         data.html_url,
+    tarball:     data.tarball_url,
+    zipball:     data.zipball_url,
+    assets: (data.assets || []).map(a => ({
+      name:        a.name,
+      size:        a.size,
+      downloadUrl: a.browser_download_url,
+      downloads:   a.download_count,
+      contentType: a.content_type,
+    })),
+  }
+}
+
+export async function githubContents(repo, path = '') {
+  const r = parseRepo(repo)
+  if (!r) throw new Error('Repo inválido')
+
+  const url  = path
+    ? `https://api.github.com/repos/${r}/contents/${path}`
+    : `https://api.github.com/repos/${r}/contents`
+  const data = await get(url)
+
+  if (Array.isArray(data)) {
+    return data.map(f => ({
+      name:     f.name,
+      path:     f.path,
+      type:     f.type,
+      size:     f.size,
+      url:      f.html_url,
+      download: f.download_url || null,
+      sha:      f.sha,
+    }))
+  }
+
+  return {
+    name:     data.name,
+    path:     data.path,
+    type:     data.type,
+    size:     data.size,
+    url:      data.html_url,
+    download: data.download_url,
+    content:  data.encoding === 'base64' ? Buffer.from(data.content, 'base64').toString('utf-8') : data.content,
+    sha:      data.sha,
+  }
+}
+
+export async function githubSearch(query, type = 'repositories', limit = 5) {
+  const validTypes = ['repositories', 'users', 'code', 'issues']
+  if (!validTypes.includes(type)) throw new Error('Tipo inválido. Usá: ' + validTypes.join(', '))
+
+  const data = await get(
+    `https://api.github.com/search/${type}?q=${encodeURIComponent(query)}&per_page=${limit}`
+  )
+
+  const items = data.items || []
+
+  if (type === 'repositories') {
+    return items.map(r => ({
+      name:        r.full_name,
+      description: r.description || '',
+      url:         r.html_url,
+      stars:       r.stargazers_count,
+      forks:       r.forks_count,
+      language:    r.language || '',
+      updatedAt:   r.updated_at,
+    }))
+  }
+
+  if (type === 'users') {
+    return items.map(u => ({
+      login:  u.login,
+      url:    u.html_url,
+      avatar: u.avatar_url,
+      type:   u.type,
+    }))
+  }
+
+  return items.slice(0, limit)
+}

package/src/scrapers/index.js

@@ -0,0 +1,15 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+export { ytInfo, ytDownload, ytSearch }                          from './youtube.js'
+export { ytInfoV2, ytDownloadV2, getFileSizeV2 }                 from './youtubev2.js'
+export { tiktokInfo, tiktokDownload }                            from './tiktok.js'
+export { fbDownload }                                            from './facebook.js'
+export { tweetInfo, tweetDownload }                              from './twitter.js'
+export { mediafireInfo }                                         from './mediafire.js'
+export { githubInfo, githubRelease, githubContents, githubSearch } from './github.js'
+export { apkSearch, apkInfo }                                    from './apk.js'

package/src/scrapers/mediafire.js

@@ -0,0 +1,77 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+import * as cheerio from 'cheerio'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+}
+
+function parseKey(url) {
+  const m = url.match(/mediafire\.com\/file\/([a-z0-9]+)/)
+  return m ? m[1] : null
+}
+
+function deduplicateName(raw) {
+  const clean = raw.trim().replace(/\s+/g, ' ')
+  const half  = Math.ceil(clean.length / 2)
+  const first = clean.slice(0, half)
+  const second = clean.slice(half).trim()
+  return second.startsWith(first.trim()) ? first.trim() : clean
+}
+
+async function tryPage(url) {
+  const res  = await axios.get(url, { headers: HEADERS, timeout: 15000 })
+  const $    = cheerio.load(res.data)
+  const link = $('a#downloadButton').attr('href') || $('a.input').attr('href')
+  if (!link) throw new Error('page: sin link de descarga')
+  const name = deduplicateName($('div.filename').text())
+  const size = $('ul.details li').first().text().replace('File size:', '').trim()
+  return { link, name, size }
+}
+
+async function tryAPI(key) {
+  const res  = await axios.get(
+    `https://www.mediafire.com/api/1.5/file/get_links.php?quick_key=${key}&link_type=normal_download&response_format=json`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+  const data = res.data?.response
+  if (data?.result !== 'Success') throw new Error('api: ' + (data?.message || 'sin resultado'))
+  const dl = data?.links?.[0]?.normal_download
+  if (!dl) throw new Error('api: sin download link')
+  return dl
+}
+
+export async function mediafireInfo(url) {
+  if (!url.includes('mediafire.com')) throw new Error('URL de MediaFire inválida')
+
+  const key    = parseKey(url)
+  const errors = []
+  let   info   = null
+
+  try {
+    info = await tryPage(url)
+  } catch (e) { errors.push('page: ' + e.message) }
+
+  if (!info?.link && key) {
+    try {
+      const link = await tryAPI(key)
+      info = { ...(info || {}), link }
+    } catch (e) { errors.push('api: ' + e.message) }
+  }
+
+  if (!info?.link) throw new Error('No se pudo obtener el link. Errores: ' + errors.join(' | '))
+
+  return {
+    key:      key || '',
+    name:     info.name || '',
+    size:     info.size || '',
+    download: info.link,
+    url,
+  }
+}

package/src/scrapers/tiktok.js

@@ -0,0 +1,58 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+}
+
+async function resolveUrl(url) {
+  if (url.includes('vm.tiktok.com') || url.includes('vt.tiktok.com')) {
+    const res = await axios.get(url, { headers: HEADERS, maxRedirects: 5, timeout: 10000 })
+    return res.request?.res?.responseUrl || res.config?.url || url
+  }
+  return url
+}
+
+export async function tiktokDownload(url) {
+  const resolved = await resolveUrl(url)
+  const res      = await axios.get(
+    `https://tikwm.com/api/?url=${encodeURIComponent(resolved)}`,
+    { headers: HEADERS, timeout: 20000 }
+  )
+
+  const data = res.data
+  if (data?.code !== 0 || !data?.data) throw new Error('tikwm: ' + (data?.msg || 'sin datos'))
+
+  const d = data.data
+  return {
+    id:          d.id       || '',
+    title:       d.title    || '',
+    author:      d.author?.nickname || d.author?.unique_id || '',
+    thumbnail:   d.cover    || d.origin_cover || '',
+    duration:    d.duration || 0,
+    nowatermark: d.play     || null,
+    watermark:   d.wmplay   || null,
+    audio:       d.music    || null,
+    music: {
+      title:  d.music_info?.title  || '',
+      author: d.music_info?.author || '',
+      url:    d.music_info?.play   || null,
+      cover:  d.music_info?.cover  || '',
+    },
+    plays:     d.play_count    || 0,
+    likes:     d.digg_count    || 0,
+    comments:  d.comment_count || 0,
+    shares:    d.share_count   || 0,
+    source:    'tikwm',
+  }
+}
+
+export async function tiktokInfo(url) {
+  return tiktokDownload(url)
+}

package/src/scrapers/twitter.js

@@ -0,0 +1,106 @@
+
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+  'Referer':    'https://platform.twitter.com/',
+}
+
+function parseTweetId(url) {
+  const m = url.match(/\/status\/(\d+)/)
+  return m ? m[1] : (/^\d+$/.test(url) ? url : null)
+}
+
+function parseMedia(details) {
+  if (!details?.length) return []
+  return details.map(m => {
+    if (m.type === 'video' || m.type === 'animated_gif') {
+      const variants = m.video_info?.variants || []
+      const best     = variants
+        .filter(v => v.content_type === 'video/mp4')
+        .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0]
+      return {
+        type:      m.type === 'animated_gif' ? 'gif' : 'video',
+        url:       best?.url || '',
+        thumbnail: m.media_url_https + '?format=jpg&name=large',
+        width:     m.original_info?.width  || 0,
+        height:    m.original_info?.height || 0,
+        variants:  variants.filter(v => v.url).map(v => ({
+          url:         v.url,
+          contentType: v.content_type,
+          bitrate:     v.bitrate || 0,
+        })),
+      }
+    }
+    return {
+      type:   'photo',
+      url:    m.media_url_https + '?format=jpg&name=orig',
+      thumb:  m.media_url_https + '?format=jpg&name=small',
+      width:  m.original_info?.width  || 0,
+      height: m.original_info?.height || 0,
+    }
+  })
+}
+
+export async function tweetInfo(url) {
+  const id = parseTweetId(url)
+  if (!id) throw new Error('URL/ID de Twitter inválido')
+
+  const res = await axios.get(
+    `https://cdn.syndication.twimg.com/tweet-result?id=${id}&lang=en&features=tfw_timeline_list%3A%3Btfw_follower_count_sunset%3Atrue&token=abc123`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+
+  const d = res.data
+  if (!d?.id_str) throw new Error('Tweet no encontrado o privado')
+
+  const medias = parseMedia(d.mediaDetails)
+
+  return {
+    id:         d.id_str,
+    text:       d.text || '',
+    lang:       d.lang || '',
+    createdAt:  d.created_at || '',
+    likes:      d.favorite_count || 0,
+    replies:    d.conversation_count || 0,
+    author: {
+      id:       d.user?.id_str || '',
+      name:     d.user?.name || '',
+      username: d.user?.screen_name || '',
+      avatar:   d.user?.profile_image_url_https?.replace('_normal', '') || '',
+      verified: d.user?.is_blue_verified || false,
+    },
+    hashtags:   d.entities?.hashtags?.map(h => h.text) || [],
+    mentions:   d.entities?.user_mentions?.map(m => m.screen_name) || [],
+    urls:       d.entities?.urls?.map(u => u.expanded_url) || [],
+    medias,
+    url:        `https://x.com/${d.user?.screen_name}/status/${d.id_str}`,
+  }
+}
+
+export async function tweetDownload(url) {
+  const info = await tweetInfo(url)
+  const videos = info.medias.filter(m => m.type === 'video' || m.type === 'gif')
+  const photos = info.medias.filter(m => m.type === 'photo')
+
+  if (!videos.length && !photos.length)
+    throw new Error('Este tweet no tiene media descargable')
+
+  return {
+    id:        info.id,
+    text:      info.text,
+    author:    info.author,
+    createdAt: info.createdAt,
+    videos,
+    photos,
+    hasVideo:  videos.length > 0,
+    hasPhoto:  photos.length > 0,
+  }
+}