@soyaxell09/zenbot-scraper 1.1.5 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soyaxell09/zenbot-scraper",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Scrapers de descarga y búsqueda para bots de WhatsApp — YouTube, TikTok, Instagram, Facebook, Twitter, Pinterest, MediaFire, GitHub, APK, Google Drive, XNXX, PornHub, XVideos, XHamster, Rule34, Screenshot y más.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -8,6 +8,8 @@
 export { ytInfo, ytDownload, ytSearch, getFileSize }               from './scrapers/youtube.js'
 export { youtubeDownload }               from './scrapers/youtubev2.js'
 export { tiktokInfo, tiktokDownload }                              from './scrapers/tiktok.js'
+export { snaptikDownload }                                        from './scrapers/snaptik.js'
+export { deezerSearch, deezerTrack }                              from './scrapers/deezer.js'
 export { igDownload, igReelDownload, igStalk, igStories }         from './scrapers/instagram.js'
 export { threadsDownload }                                         from './scrapers/threads.js'
 export { spotidownTrack }                                          from './scrapers/spotidown.js'
@@ -21,6 +23,7 @@ export { googleSearch }                                            from './searc
 export { giphy, gifNext, giphyBuffer }                             from './search/giphy.js'
 export { pinsearch, pinimg, pinvid }                               from './search/pinterest.js'
 export { stickerSearch }                                           from './search/stickersearch.js'
+export { deezerFind, deezerSearchAlbum, deezerSearchArtist, deezerAlbumTracks, deezerArtistTopTracks }                              from './search/deezersearch.js'
 export { animeImage }                                              from './search/anime.js'
 export { wallpaperSearch }                                         from './search/wallpaper.js'
 export { tiktokStalk }                                             from './tools/tiktokstalk.js'

package/src/scrapers/deezer.js

@@ -0,0 +1,98 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const UA      = 'Mozilla/5.0 (Linux; Android 11; Redmi Note 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36'
+const BASE    = 'https://flacdownloader.com'
+const APIBASE = `${BASE}/flac`
+const KEY     = 'l@p*gute)77=g5clebcp4lz#=x%(*rwg+ku0_)bh=&%6wg!a'
+
+const HEADERS = {
+  'User-Agent': UA,
+  'Referer': `${BASE}/`,
+}
+
+export async function deezerSearch(query, limit = 10) {
+  const { data } = await axios.get(`${APIBASE}/search`, {
+    params: { query },
+    headers: HEADERS,
+    timeout: 12000,
+  })
+
+  return (data.data || []).slice(0, limit).map(t => ({
+    id:       t.id,
+    title:    t.title,
+    duration: t.duration,
+    preview:  t.preview,
+    explicit: t.explicit_lyrics,
+    link:     t.link,
+    artist: {
+      id:     t.artist?.id,
+      name:   t.artist?.name,
+      picture: t.artist?.picture_medium,
+    },
+    album: {
+      id:    t.album?.id,
+      title: t.album?.title,
+      cover: t.album?.cover_medium,
+      cover_xl: t.album?.cover_xl,
+    },
+  }))
+}
+
+export async function deezerDownload(trackId, format = 'flac') {
+  const { data: tokenData } = await axios.get(`${APIBASE}/download-token`, {
+    params: { t: trackId, f: format },
+    headers: { ...HEADERS, 'X-Download-Access': KEY },
+    timeout: 10000,
+  })
+
+  const { token, expires } = tokenData
+
+  const dlRes = await axios.get(`${APIBASE}/download`, {
+    params: {
+      t: trackId,
+      f: format,
+      token,
+      expires,
+    },
+    headers: HEADERS,
+    responseType: 'arraybuffer',
+    timeout: 60000,
+  })
+
+  const ext      = format.toLowerCase().includes('flac') ? 'flac' : 'mp3'
+  const mimeType = ext === 'flac' ? 'audio/flac' : 'audio/mpeg'
+
+  return {
+    buffer:   Buffer.from(dlRes.data),
+    ext,
+    mimeType,
+    size:     parseInt(dlRes.headers['content-length'] || '0', 10),
+  }
+}
+
+export async function deezerTrack(query, format = 'mp3') {
+  const results = await deezerSearch(query, 1)
+  if (!results.length) throw new Error('No se encontraron resultados.')
+
+  const track    = results[0]
+  const download = await deezerDownload(track.id, format)
+
+  return {
+    title:    track.title,
+    artist:   track.artist.name,
+    album:    track.album.title,
+    duration: track.duration,
+    cover:    track.album.cover_xl,
+    preview:  track.preview,
+    link:     track.link,
+    explicit: track.explicit,
+    download,
+  }
+}

package/src/scrapers/index.js

@@ -1,6 +1,9 @@
 export { ytInfo, ytDownload, ytSearch, getFileSize }               from './youtube.js'
 export { youtubeDownload }                                         from './youtubev2.js'
 export { tiktokInfo, tiktokDownload }                              from './tiktok.js'
+export { tiktokSearch }                                           from './tiktok.js'
+export { snaptikDownload }                                        from './snaptik.js'
+export { deezerSearch, deezerTrack }                              from './deezer.js'
 export { fbDownload }                                              from './facebook.js'
 export { tweetInfo, tweetDownload }                                from './twitter.js'
 export { mediafireInfo }                                           from './mediafire.js'

package/src/scrapers/snaptik.js

@@ -0,0 +1,137 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+import * as cheerio from 'cheerio'
+import { createContext, runInContext } from 'vm'
+
+const UA      = 'Mozilla/5.0 (Linux; Android 11; Redmi Note 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36'
+const BASE    = 'https://snaptik.app'
+const HEADERS = { 'User-Agent': UA }
+
+function decodeObfuscated(jsCode) {
+  const patched = jsCode
+    .replace(/eval\(function\(h,u,n,t,e,r\)/, 'decoded=(function(h,u,n,t,e,r)')
+    .replace(/\}\)\s*$/, '})')
+  try {
+    const ctx = createContext({ decoded: '' })
+    runInContext(patched, ctx, { timeout: 5000 })
+    return ctx.decoded || ''
+  } catch { return '' }
+}
+
+function extractInnerHTML(decoded) {
+  const marker = 'innerHTML = "'
+  const idx    = decoded.indexOf(marker)
+  if (idx === -1) return ''
+  const start = idx + marker.length
+  const end   = decoded.indexOf('"; $(', start)
+  if (end === -1) return ''
+  return decoded.slice(start, end)
+    .replace(/\\"/g, '"')
+    .replace(/\\n/g,  '\n')
+    .replace(/\\\//g, '/')
+}
+
+export async function snaptikDownload(url) {
+  if (!url?.trim()) throw new Error('Se requiere una URL de TikTok')
+
+  const r0 = await axios.get(`${BASE}/en2`, {
+    headers: HEADERS,
+    timeout: 12000,
+  })
+  const $0      = cheerio.load(r0.data)
+  const token   = $0('input[name="token"]').val() || ''
+  const cookies = r0.headers['set-cookie']?.map(c => c.split(';')[0]).join('; ') || ''
+
+  if (!token) throw new Error('No se pudo obtener el token de snaptik')
+
+  const params = new URLSearchParams({ url, token, lang: 'en2' })
+  const { data } = await axios.post(`${BASE}/abc2.php`, params, {
+    headers: {
+      ...HEADERS,
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Referer':      `${BASE}/en2`,
+      'Origin':       BASE,
+      'Cookie':       cookies,
+    },
+    timeout: 15000,
+  })
+
+  const raw     = typeof data === 'string' ? data : JSON.stringify(data)
+  const decoded = decodeObfuscated(raw)
+
+  if (!decoded) throw new Error('No se pudo decodificar el response de snaptik')
+
+  if (decoded.includes('showAlert')) {
+    const msgMatch = decoded.match(/showAlert\("([^"]+)"/)
+    throw new Error(msgMatch?.[1] || 'Error en snaptik al procesar la URL')
+  }
+
+  const html = extractInnerHTML(decoded)
+  if (!html) throw new Error('No se encontró HTML de descarga en el response')
+
+  const $ = cheerio.load(html)
+
+  const title     = $('.video-title').text().trim()
+  const thumbnail = $('#thumbnail').attr('src') || $('img.avatar').attr('src') || ''
+
+  const btnToken = $('button.btn-render').attr('data-token') || ''
+  if (btnToken) {
+    let imageUrls = []
+    try {
+      const payload = btnToken.split('.')[1] || ''
+      const json    = JSON.parse(Buffer.from(payload, 'base64').toString('utf8'))
+      imageUrls     = json.image_urls || []
+    } catch {}
+
+    if (!imageUrls.length) {
+      $('img').each((_, el) => {
+        const src = $(el).attr('src') || ''
+        if (src.includes('tiktokcdn') && !src.includes('avatar')) {
+          imageUrls.push(src)
+        }
+      })
+      imageUrls = [...new Set(imageUrls)]
+    }
+
+    const downloadUrls = []
+    $('a[href*="rapidcdn"]').each((_, el) => {
+      const href = $(el).attr('href') || ''
+      if (href) downloadUrls.push(href)
+    })
+
+    if (imageUrls.length || downloadUrls.length) {
+      return {
+        title,
+        thumbnail,
+        type: 'images',
+        images: imageUrls,
+        imagesWm: downloadUrls,
+        source: 'snaptik',
+      }
+    }
+  }
+
+  const sdUrl    = $('a.download-file').first().attr('href') || ''
+  const hdApiUrl = $('button[data-tokenhd]').attr('data-tokenhd') || ''
+  const hdBackup = $('button[data-backup]').attr('data-backup') || ''
+
+  if (!sdUrl) throw new Error('No se encontró URL de descarga')
+
+  return {
+    title,
+    thumbnail,
+    type: 'video',
+    download: {
+      sd:    sdUrl,
+      hd:    hdBackup || null,
+      hdApi: hdApiUrl || null,
+    },
+    source: 'snaptik',
+  }
+}

package/src/search/deezersearch.js

@@ -0,0 +1,128 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const UA   = 'Mozilla/5.0 (Linux; Android 11; Redmi Note 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36'
+const BASE = 'https://api.deezer.com'
+
+async function get(endpoint, params = {}) {
+  const { data } = await axios.get(`${BASE}${endpoint}`, {
+    params,
+    headers: { 'User-Agent': UA },
+    timeout: 12000,
+  })
+  if (data?.error) throw new Error(data.error.message || 'Error en Deezer API')
+  return data
+}
+
+function formatDuration(ms) {
+  if (!ms) return null
+  const s   = Math.floor(ms / 1000)
+  const m   = Math.floor(s / 60)
+  const sec = s % 60
+  return `${m}:${sec.toString().padStart(2, '0')}`
+}
+
+export async function deezerFind(query, limit = 10) {
+  if (!query?.trim()) throw new Error('Se requiere un término de búsqueda')
+  const data = await get('/search', { q: query, limit })
+  if (!data?.data?.length) throw new Error('Sin resultados')
+  return data.data.map(t => ({
+    id:       t.id,
+    title:    t.title,
+    artist:   t.artist?.name,
+    artistId: t.artist?.id,
+    album:    t.album?.title,
+    albumId:  t.album?.id,
+    cover:    t.album?.cover_medium,
+    coverHd:  t.album?.cover_xl || t.album?.cover_big,
+    preview:  t.preview,
+    duration: formatDuration(t.duration * 1000),
+    link:     t.link,
+    rank:     t.rank,
+  }))
+}
+
+export async function deezerSearchAlbum(query, limit = 10) {
+  if (!query?.trim()) throw new Error('Se requiere un término de búsqueda')
+  const data = await get('/search/album', { q: query, limit })
+  if (!data?.data?.length) throw new Error('Sin resultados')
+  return data.data.map(a => ({
+    id:          a.id,
+    title:       a.title,
+    artist:      a.artist?.name,
+    artistId:    a.artist?.id,
+    cover:       a.cover_medium,
+    coverHd:     a.cover_xl || a.cover_big,
+    tracks:      a.nb_tracks,
+    releaseDate: a.release_date,
+    link:        a.link,
+  }))
+}
+
+export async function deezerSearchArtist(query, limit = 10) {
+  if (!query?.trim()) throw new Error('Se requiere un término de búsqueda')
+  const data = await get('/search/artist', { q: query, limit })
+  if (!data?.data?.length) throw new Error('Sin resultados')
+  return data.data.map(a => ({
+    id:      a.id,
+    name:    a.name,
+    picture: a.picture_medium,
+    pictureHd: a.picture_xl || a.picture_big,
+    fans:    a.nb_fan,
+    link:    a.link,
+  }))
+}
+
+export async function deezerAlbumTracks(albumId, limit = 50) {
+  if (!albumId) throw new Error('Se requiere un ID de álbum')
+  const data = await get(`/album/${albumId}/tracks`, { limit })
+  if (!data?.data?.length) throw new Error('Sin tracks')
+  const album = await get(`/album/${albumId}`)
+  return {
+    id:          album.id,
+    title:       album.title,
+    artist:      album.artist?.name,
+    cover:       album.cover_medium,
+    coverHd:     album.cover_xl || album.cover_big,
+    releaseDate: album.release_date,
+    genre:       album.genres?.data?.[0]?.name || null,
+    tracks:      data.data.map(t => ({
+      id:       t.id,
+      title:    t.title,
+      duration: formatDuration(t.duration * 1000),
+      preview:  t.preview,
+      link:     `https://www.deezer.com/track/${t.id}`,
+    }))
+  }
+}
+
+export async function deezerArtistTopTracks(artistId, limit = 10) {
+  if (!artistId) throw new Error('Se requiere un ID de artista')
+  const data = await get(`/artist/${artistId}/top`, { limit })
+  if (!data?.data?.length) throw new Error('Sin tracks')
+  const artist = await get(`/artist/${artistId}`)
+  return {
+    id:        artist.id,
+    name:      artist.name,
+    picture:   artist.picture_medium,
+    pictureHd: artist.picture_xl || artist.picture_big,
+    fans:      artist.nb_fan,
+    link:      artist.link,
+    tracks:    data.data.map(t => ({
+      id:       t.id,
+      title:    t.title,
+      album:    t.album?.title,
+      cover:    t.album?.cover_medium,
+      duration: formatDuration(t.duration * 1000),
+      preview:  t.preview,
+      rank:     t.rank,
+      link:     `https://www.deezer.com/track/${t.id}`,
+    }))
+  }
+}

package/src/search/index.js

@@ -9,6 +9,7 @@ export { ytSearch }                                    from './youtube.js'
 export { googleSearch }                                from './google.js'
 export { giphy, gifNext, giphyBuffer }                 from './giphy.js'
 export { pinsearch, pinimg, pinvid }                   from './pinterest.js'
+export { deezerFind, deezerSearchAlbum, deezerSearchArtist, deezerAlbumTracks, deezerArtistTopTracks }                   from './deezersearch.js'
 export { stickerSearch }                               from './stickersearch.js'
 export { animeImage }                                  from './anime.js'
 export { wallpaperSearch }                             from './wallpaper.js'

package/src/tools/ia.js

@@ -1,74 +0,0 @@
-/*
- * © Created by AxelDev09 🔥
- * GitHub: https://github.com/AxelDev09
- * Instagram: @axeldev09
- * Deja los créditos we 🗣️
- */
-
-import axios from 'axios'
-
-const UA = 'Mozilla/5.0 (Linux; Android 11; Redmi Note 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36'
-const BASE = 'https://api.delirius.store'
-
-const headers = { 'User-Agent': UA }
-
-export async function copilot(query) {
-  if (!query) throw new Error('query es requerido')
-  const { data } = await axios.get(`${BASE}/ia/copilot`, {
-    params: { query },
-    headers,
-    timeout: 12000,
-  })
-  if (!data?.text) throw new Error('Sin respuesta')
-  return {
-    text:           data.text,
-    citations:      data.citations || [],
-    conversationId: data.conversationId || null,
-  }
-}
-
-export async function gemini(query) {
-  if (!query) throw new Error('query es requerido')
-  const { data } = await axios.get(`${BASE}/ia/gemini`, {
-    params: { query },
-    headers,
-    timeout: 12000,
-  })
-  if (!data?.status || !data?.data?.result) throw new Error('Sin respuesta')
-  return { text: data.data.result }
-}
-
-export async function chatgpt(query) {
-  if (!query) throw new Error('query es requerido')
-  const { data } = await axios.get(`${BASE}/ia/chatgpt`, {
-    params: { q: query },
-    headers,
-    timeout: 12000,
-  })
-  if (!data?.status || !data?.data) throw new Error('Sin respuesta')
-  return { text: data.data }
-}
-
-export async function gptPrompt(text, prompt = '') {
-  if (!text) throw new Error('text es requerido')
-  const params = { text }
-  if (prompt) params.prompt = prompt
-  const { data } = await axios.get(`${BASE}/ia/gptprompt`, {
-    params,
-    headers,
-    timeout: 12000,
-  })
-  if (!data?.status || !data?.data) throw new Error('Sin respuesta')
-  return { text: data.data }
-}
-
-export async function ripleai(query) {
-  if (!query) throw new Error('query es requerido')
-  const { data } = await axios.get(`${BASE}/ia/ripleai`, {
-    params: { query },
-    headers,
-    timeout: 12000,
-  })
-  if (!data?.status || !data?.data?.result) throw new Error('Sin respuesta')
-  return { text: data.data.result }
-}