]*src="([^"]+)"[^>]*>/);
let thumbnail = '';
if (thumbMatch) {
thumbnail = thumbMatch[1].startsWith('http') ? thumbMatch[1] : BASE_URL + thumbMatch[1];
}
// -- Extract channel name --
const chMatch = cardHtml.match(/]*>([\s\S]*?)<\/p>/);
let channel = '';
if (chMatch) {
channel = chMatch[1]
.replace(/<[^>]+>/g, '')
.replace(/ /g, ' ')
.replace(/&/g, '&')
.trim();
}
// -- Channel ID --
const chIdMatch = cardHtml.match(/\/channel\/(UC[a-zA-Z0-9_-]+)/);
const channelId = chIdMatch ? chIdMatch[1] : '';
// -- Extract views & published from .video-data --
const videoDataMatches = [...cardHtml.matchAll(/
]*>([\s\S]*?)<\/p>/g)];
let published = '';
let views = '';
for (const vdMatch of videoDataMatches) {
const text = vdMatch[1]
.replace(/<[^>]+>/g, '')
.replace(/ /g, ' ')
.trim();
if (/views?/i.test(text)) {
views = text;
} else if (/(Shared|Streamed|Premiered|ago)/i.test(text)) {
published = text;
}
}
results.push({
title,
url: `https://www.youtube.com/watch?v=${videoId}`,
videoId,
channel,
channelId,
channelUrl: channelId ? `https://www.youtube.com/channel/${channelId}` : '',
duration,
thumbnail,
views,
published,
});
}
return results;
}
module.exports = { search };
---
// FILE: lib\yahooSpotify.js
const cheerio = require('cheerio');
/**
* Spotify Search via Yahoo (Single Engine dengan Retry + Cookie)
* Mencari track Spotify melalui Yahoo Search.
* Jika gagal, retry otomatis dengan cookies dari permintaan sebelumnya.
* Jika gagal 2x, throw error.
*
* @class YahooSpotifyScraper
*/
class YahooSpotifyScraper {
constructor() {
this.timeout = 15000;
/** @type {string|null} Cookie jar: menyimpan cookies dari response sebelumnya */
this._cookies = null;
}
/**
* Ekstrak track ID dari URL Spotify
* @param {string} spotifyUrl
* @returns {string|null}
*/
_extractTrackId(spotifyUrl) {
if (!spotifyUrl) return null;
const match = spotifyUrl.match(/\/track\/([a-zA-Z0-9]+)/);
return match ? match[1] : null;
}
/**
* Bersihkan judul dari breadcrumb dan artefak URL
* @param {string} rawTitle
* @returns {string}
*/
_cleanTitle(rawTitle) {
if (!rawTitle) return '';
let title = rawTitle;
// Hapus "Spotify" prefix
title = title.replace(/^Spotify\s*/i, '');
// Hapus URL + breadcrumb
title = title
.replace(/https?:\/\/open\.spotify\.com\s*[›»]?\s*\/?\s*intl-id\s*[›»]?\s*\/?\s*track\s*\/?/gi, '')
.replace(/open\.spotify\.com\s*[›»]\s*intl-id\s*[›»]\s*track\s*/gi, '')
.replace(/open\.spotify\.com\/intl-id\/track\s*/gi, '')
.replace(/https?:\/\/open\.spotify\.com\/track\s*/gi, '');
// Hapus " - lagu dan lirik oleh ..." atau " - lagu oleh ..."
title = title.replace(/\s*[-–]\s*lagu\s*(dan\s*lirik)?\s*oleh\s+.*$/i, '');
// Hapus " | Spotify" atau " | ..." di akhir
title = title.replace(/\s*\|.*$/, '');
// Bersihkan spasi berlebih
title = title.replace(/\s+/g, ' ').trim();
// Jika hasilnya adalah track ID saja (hanya alfanumerik)
if (/^[a-zA-Z0-9]+$/.test(title)) {
return `Spotify Track ${title}`;
}
// Jika masih mengandung http/URL, ambil kata-kata non-URL saja
if (title.includes('http') || title.includes('spotify.com')) {
const parts = title.split(/\s+/);
const cleanParts = parts.filter(p => !p.includes('http') && !p.includes('spotify.com'));
if (cleanParts.length > 0) {
title = cleanParts.join(' ');
}
}
return title.trim() || `Spotify Track`;
}
/**
* Ekstrak URL asli dari redirect Yahoo (parameter RU)
* @param {string} yahooUrl
* @returns {string|null}
*/
_extractRealUrl(yahooUrl) {
if (!yahooUrl) return null;
const match = yahooUrl.match(/RU=([^/&]+)/);
if (match && match[1]) {
try {
const decoded = decodeURIComponent(match[1]);
return decoded.split('/RK=')[0];
} catch (e) {
return null;
}
}
return null;
}
/**
* Fetch dengan cookie jar internal
* @param {string} url
* @param {object} [customHeaders={}]
* @returns {Promise<{html: string, headers: Headers}>}
*/
async _fetch(url, customHeaders = {}) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), this.timeout);
try {
const headers = { ...customHeaders };
// Sisipkan cookies jika ada
if (this._cookies) {
headers['Cookie'] = this._cookies;
}
const response = await fetch(url, {
headers,
signal: controller.signal,
redirect: 'follow'
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}${response.statusText ? ': ' + response.statusText : ''}`);
}
// Simpan cookies dari response untuk retry nanti
const setCookie = response.headers.get('set-cookie');
if (setCookie) {
// Ambil bagian cookie saja (nama=value), buang atribut
const parsed = setCookie.split(',').map(c => c.split(';')[0].trim()).filter(Boolean);
if (parsed.length > 0) {
this._cookies = parsed.join('; ');
}
}
return {
html: await response.text(),
headers: response.headers
};
} finally {
clearTimeout(timer);
}
}
/**
* Cari track Spotify via Yahoo Search
* @param {string} query
* @param {number} offset
* @returns {Promise}
*/
async _searchYahoo(query, offset) {
const params = new URLSearchParams({
p: `site:spotify.com/intl-id/track ${query}`,
b: offset,
ei: 'UTF-8'
});
const url = `https://id.search.yahoo.com/search?${params.toString()}`;
const { html } = await this._fetch(url, {
'User-Agent': 'Mozilla/5.0 (Linux; Android 10; SM-G973F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
'Accept-Language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7'
});
const $ = cheerio.load(html);
const results = [];
const seenIds = new Set();
// Cari semua link Yahoo redirect yang mengandung Spotify track
$('a[href*="r.search.yahoo.com"]').each((i, el) => {
const href = $(el).attr('href');
if (!href || !href.includes('/RU=')) return;
const realUrl = this._extractRealUrl(href);
if (!realUrl || !realUrl.includes('open.spotify.com/intl-id/track')) return;
const trackId = this._extractTrackId(realUrl);
if (!trackId || seenIds.has(trackId)) return;
seenIds.add(trackId);
const title = this._cleanTitle($(el).text());
results.push({
title: title || `Spotify Track ${trackId}`,
trackID: trackId,
trackURL: realUrl.split('?')[0]
});
});
// Fallback: cari langsung di HTML untuk URL encoded
if (results.length === 0) {
const encodedMatches = html.match(/open\.spotify\.com%2fintl-id%2ftrack%2f([a-zA-Z0-9]+)/gi);
if (encodedMatches) {
encodedMatches.forEach(match => {
try {
const decoded = decodeURIComponent(match);
const trackId = decoded.match(/\/track\/([a-zA-Z0-9]+)/);
if (trackId && !seenIds.has(trackId[1])) {
seenIds.add(trackId[1]);
results.push({
title: `Spotify Track ${trackId[1]}`,
trackID: trackId[1],
trackURL: `https://open.spotify.com/intl-id/track/${trackId[1]}`
});
}
} catch (e) {
// Skip invalid encoded URLs
}
});
}
}
return results;
}
/**
* Cari track Spotify via Yahoo Search dengan retry mechanism.
*
* Alur:
* 1. Coba Yahoo Search pertama kali
* 2. Jika gagal → retry dengan cookies dari sebelumnya (jika ada)
* 3. Jika gagal 2x → throw error
*
* @param {string} query - Kata kunci pencarian
* @param {number} [offset=1] - Halaman hasil pencarian
* @returns {Promise>}
*
* @example
* const scraper = require('./lib/yahooSpotify');
* const results = await scraper.search('dj ya odna');
* // => [{ title: '...', trackID: '...', trackURL: '...' }, ...]
*/
async search(query, offset = 1) {
if (!query || typeof query !== 'string') {
throw new Error("Parameter 'query' wajib diisi.");
}
let lastError = null;
// Percobaan ke-1
try {
const results = await this._searchYahoo(query, offset);
if (results && results.length > 0) {
return results;
}
lastError = new Error('Yahoo tidak mengembalikan hasil');
} catch (error) {
lastError = error;
}
// Percobaan ke-2 (retry dengan cookies)
try {
const results = await this._searchYahoo(query, offset);
if (results && results.length > 0) {
return results;
}
lastError = new Error('Yahoo tidak mengembalikan hasil (retry)');
} catch (error) {
lastError = error;
}
// Gagal 2x — throw error
throw new Error(`Gagal mencari di Yahoo setelah 2 percobaan: ${lastError.message}`);
}
}
module.exports = new YahooSpotifyScraper();
---
// FILE: lib\yahooSoundcloud.js
const axios = require('axios');
const cheerio = require('cheerio');
/**
* YahooSoundCloudScraper V2
* Output yang lebih bersih dan deteksi tipe konten.
*/
class YahooSoundCloudScraper {
constructor() {
this.baseUrl = 'https://id.search.yahoo.com/search';
this.headers = {
'User-Agent': 'Mozilla/5.0 (Linux; Android 10; SM-G973F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
'Accept-Language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7'
};
}
/**
* Ekstraksi URL asli dari redirector Yahoo menggunakan Regex
*/
_extractSoundCloudUrl(yahooUrl) {
if (!yahooUrl) return null;
// Mencari pola RU=... sampai akhir segment sebelum /RK atau &
const match = yahooUrl.match(/RU=([^/&]+)/);
if (match && match[1]) {
try {
const decoded = decodeURIComponent(match[1]);
return decoded.split('/RK=')[0]; // Bersihkan sisa parameter tracking
} catch (e) {
return yahooUrl;
}
}
return yahooUrl;
}
/**
* Menentukan apakah konten berupa track atau playlist
*/
_determineType(url) {
if (!url) return 'unknown';
return url.includes('/sets/') ? 'playlist' : 'track';
}
/**
* Membersihkan judul dari breadcrumb Yahoo (seperti 'SoundCloud https://...')
*/
_cleanTitle(rawTitle) {
if (!rawTitle) return '';
// Yahoo sering menggabungkan breadcrumb di awal.
// Kita ambil bagian setelah teks "SoundCloud" atau segment URL.
const parts = rawTitle.split(' - SoundCloud');
let title = parts[0];
// Hapus sisa-sisa breadcrumb URL jika masih ada
if (title.includes('https://')) {
const cleanParts = title.split(/\s+/);
// Ambil hanya teks yang bukan bagian dari URL navigasi
title = cleanParts.filter(p => !p.includes('http') && !p.includes('›') && p.toLowerCase() !== 'soundcloud').join(' ');
}
return title.trim();
}
async search(query, offset = 1) {
try {
const params = {
p: `site://soundcloud.com ${query}`,
b: offset,
ei: 'UTF-8',
nojs: '1'
};
const response = await axios.get(this.baseUrl, { params, headers: this.headers });
const $ = cheerio.load(response.data);
const finalData = [];
$('section.algo-sr').each((i, el) => {
const anchor = $(el).find('.compTitle a');
const rawUrl = anchor.attr('href');
const scUrl = this._extractSoundCloudUrl(rawUrl);
if (scUrl && scUrl.includes('soundcloud.com')) {
finalData.push({
title: this._cleanTitle(anchor.text()),
url: scUrl,
type: this._determineType(scUrl),
description: $(el).find('.s-desc').text().replace(/^.*?\d{4}\s·\s/, '').trim()
});
}
});
return finalData;
} catch (error) {
throw new Error(error.message);
}
}
}
module.exports = new YahooSoundCloudScraper();
---
// FILE: lib\yahooSearch.js
const axios = require('axios');
const cheerio = require('cheerio');
/**
* Yahoo Search Scraper (Enhanced for Mobile/Modern Layout)
* @param {string} query - Kata kunci pencarian
*/
async function search(query) {
if (!query) throw new Error("Query is required.");
// Updated URL with parameters to match the provided context (Mobile/Standard layout)
const url = `https://search.yahoo.com/search?p=${encodeURIComponent(query)}&fr=yfp-hrmob&fr2=p:fp,m:sb&.tsrc=yfp-hrmob&ei=UTF-8&fp=1&toggle=1&cop=mss`;
try {
const response = await axios.get(url, {
headers: {
'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
'Accept-Language': 'id-ID,id;q=0.9,en-US;q=0.8',
'Referer': 'https://search.yahoo.com/'
}
});
const $ = cheerio.load(response.data);
const results = [];
// Unified selection for both Mobile and Desktop layouts found in Yahoo search results
$('.algo, .algo-sr, .Sr, .ag-1, .ag-2, .ag-3, .ag-4, .ag-5, .ag-6, .ag-7, .ag-8, .ag-9, .ag-10').each((i, el) => {
const titleNode = $(el).find('.compTitle h3 a, .compTitle a.s-title, h3 a').first();
const title = titleNode.text().trim();
let link = titleNode.attr('href');
// Extract the real URL from Yahoo's redirect link if present
if (link && link.includes('r.search.yahoo.com')) {
const match = link.match(/\/RU=([^\/]+)\//);
if (match && match[1]) {
try {
link = decodeURIComponent(match[1]);
} catch (e) {
// Keep original link if decoding fails
}
}
}
// Look for description in common mobile/desktop snippet classes
const snippet = $(el).find('.compText p, .s-desc, .compText, .st').first().text().trim();
if (title && link && link.startsWith('http')) {
results.push({
title,
link,
snippet: snippet || 'No description available.'
});
}
});
// Fallback for specific legacy or different regional layouts
if (results.length === 0) {
$('.algo-sr').each((i, el) => {
const titleNode = $(el).find('h3 a');
const title = titleNode.text().trim();
const link = titleNode.attr('href');
const snippet = $(el).find('.compText, .s-desc').text().trim();
if (title && link) {
results.push({
title,
link,
snippet: snippet || 'No description available.'
});
}
});
}
return results;
} catch (error) {
throw new Error("Gagal mengambil hasil pencarian Yahoo: " + error.message);
}
}
module.exports = { search };
---
// FILE: lib\xdownloader.js
const axios = require('axios');
const cheerio = require('cheerio');
/**
* X/Twitter Video Downloader for xsaver.io
* @param {string} twitterUrl - URL video dari X (Twitter)
*/
async function getXVideoInfo(twitterUrl) {
try {
const baseUrl = 'https://www.xsaver.io/x-downloader/';
const targetUrl = `${baseUrl}download.php?url=${encodeURIComponent(twitterUrl)}`;
const response = await axios.get(targetUrl, {
headers: {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Referer': 'https://www.xsaver.io/x-downloader/id/',
'Accept-Language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7'
}
});
const $ = cheerio.load(response.data);
const results = [];
// 1. Ambil Judul Video
const title = $('.video-title').text().trim();
// 2. Iterasi setiap item media yang ditemukan
$('.media-item').each((index, element) => {
const thumb = $(element).find('.media-thumb img').attr('src');
// Mencari link download video (save-url.php)
const downloadLinkRaw = $(element).find('a[href^="save-url.php"]').attr('href');
if (downloadLinkRaw) {
// Ekstraksi URL asli dari parameter query 'url'
const urlParams = new URLSearchParams(downloadLinkRaw.split('?')[1]);
const directVideoUrl = urlParams.get('url');
results.push({
id: index + 1,
type: 'video',
thumbnail: thumb,
url: directVideoUrl,
proxy_link: baseUrl + downloadLinkRaw
});
}
});
return {
success: true,
title: title || 'X Video',
results: results
};
} catch (error) {
return {
success: false,
message: error.message
};
}
}
module.exports = { getXVideoInfo };
---
// FILE: lib\vdfr-downloader.js
const axios = require('axios');
const cheerio = require('cheerio');
const fs = require('fs');
const path = require('path');
class VDFRDownloader {
constructor() {
this.baseUrl = 'https://vdfr.app';
this.client = axios.create({
headers: {
'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',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Language': 'en-US,en;q=0.5'
},
timeout: 15000
});
}
/**
* Mengambil link download video dari halaman hasil vdfr.app
* @param {string} instagramUrl - URL reel/post Instagram publik
* @returns {Promise} - URL unduhan dengan token JWT
*/
async getDownloadLink(instagramUrl) {
try {
// Request halaman download
const encodedUrl = encodeURIComponent(instagramUrl);
const response = await this.client.get(`${this.baseUrl}/download/`, {
params: { url: instagramUrl } // axios otomatis encoding
});
const $ = cheerio.load(response.data);
// Cari link download dengan selector spesifik
const downloadLink = $('a.download__item__info__actions__button').attr('href');
if (!downloadLink) {
// Coba alternatif: mungkin ada beberapa link
const allLinks = $('a[href*="downloads.acxcdn.com/vdfr/video?token="]');
if (allLinks.length > 0) {
return allLinks.first().attr('href');
}
throw new Error('Download link tidak ditemukan. Kemungkinan video tidak tersedia atau Instagram memblokir permintaan.');
}
return downloadLink;
} catch (error) {
if (error.response) {
throw new Error(`Server vdfr.app mengembalikan status ${error.response.status}`);
}
throw error;
}
}
/**
* Mengunduh video dari link token langsung ke file
* @param {string} downloadUrl - URL hasil dari getDownloadLink()
* @param {string} outputDir - Direktori penyimpanan (default: './downloads')
* @returns {Promise} - Path file yang berhasil diunduh
*/
async downloadVideo(downloadUrl, outputDir = './downloads') {
try {
if (!fs.existsSync(outputDir)) {
fs.mkdirSync(outputDir, { recursive: true });
}
const response = await this.client.get(downloadUrl, {
responseType: 'stream'
});
// Ambil nama file dari header Content-Disposition atau gunakan timestamp
const disposition = response.headers['content-disposition'];
let filename = `instagram_${Date.now()}.mp4`;
if (disposition) {
const match = disposition.match(/filename="(.+)"/);
if (match) filename = match[1];
}
const filePath = path.join(outputDir, filename);
const writer = fs.createWriteStream(filePath);
response.data.pipe(writer);
return new Promise((resolve, reject) => {
writer.on('finish', () => resolve(filePath));
writer.on('error', reject);
});
} catch (error) {
throw new Error(`Gagal mengunduh video: ${error.message}`);
}
}
/**
* Proses lengkap: dapatkan link -> unduh video
* @param {string} instagramUrl
* @param {string} outputDir
* @returns {Promise<{downloadLink: string, filePath: string}>}
*/
async process(instagramUrl, outputDir) {
console.log(`Mengambil link download untuk: ${instagramUrl}`);
const downloadLink = await this.getDownloadLink(instagramUrl);
console.log(`Link didapat: ${downloadLink}`);
console.log(`Mengunduh video...`);
const filePath = await this.downloadVideo(downloadLink, outputDir);
console.log(`Video tersimpan di: ${filePath}`);
return { downloadLink, filePath };
}
}
module.exports = VDFRDownloader;
---
// FILE: lib\upscale.js
const axios = require('axios');
const FormData = require('form-data');
const { uploadToTmp } = require('./uploader');
// --- KONFIGURASI CONSTANTS ---
const TARGET_URL = 'https://cloudinary.com/tools/image-upscale';
const SIGNER_URL = 'https://cloudinary-tools.netlify.app/.netlify/functions/sign-upload-params';
// --- FALLBACK CONFIG ---
const FALLBACK_CONFIG = {
cloudName: 'dtz0urit6',
apiKey: '985946268373735',
uploadPreset: 'cloudinary-tools'
};
const client = axios.create({
headers: {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Referer': TARGET_URL
}
});
/**
* 1. DYNAMIC CONFIG EXTRACTOR
*/
async function getDynamicConfig() {
try {
const htmlParams = await client.get(TARGET_URL);
const scriptMatch = htmlParams.data.match(/src="([^"]*\/app\.js[^"]*)"/);
if (!scriptMatch) throw new Error("Path app.js tidak ditemukan.");
const appJsUrl = new URL(scriptMatch[1], TARGET_URL).href;
const jsParams = await client.get(appJsUrl);
const jsContent = jsParams.data;
const cloudNameMatch = jsContent.match(/cloudName\s*=\s*\(isLocal\)\s*\?\s*'[^']+'\s*:\s*'([^']+)'/);
const apiKeyMatch = jsContent.match(/api_key\s*=\s*\(isLocal\)\s*\?\s*'[^']+'\s*:\s*'([^']+)'/);
const presetMatch = jsContent.match(/uploadPreset\s*=\s*\(isLocal\)\s*\?\s*'[^']+'\s*:\s*'([^']+)'/);
if (cloudNameMatch && apiKeyMatch && presetMatch) {
return {
cloudName: cloudNameMatch[1],
apiKey: apiKeyMatch[1],
uploadPreset: presetMatch[1]
};
}
throw new Error("Gagal regex config.");
} catch (error) {
return FALLBACK_CONFIG;
}
}
/**
* 2. SIGNATURE GENERATOR
*/
async function getSignature(config, timestamp) {
try {
const payload = {
paramsToSign: {
source: 'uw',
timestamp: timestamp,
upload_preset: config.uploadPreset
}
};
const response = await client.post(SIGNER_URL, payload, {
headers: { 'Content-Type': 'application/json' }
});
if (!response.data.signature) throw new Error("Signature kosong.");
return response.data.signature;
} catch (error) {
throw new Error(`Gagal get signature: ${error.message}`);
}
}
/**
* 3. UPLOADER (Buffer Support)
*/
async function uploadImage(config, signature, timestamp, imageBuffer) {
const form = new FormData();
form.append('file', imageBuffer, { filename: 'input.jpg' });
form.append('api_key', config.apiKey);
form.append('timestamp', timestamp);
form.append('upload_preset', config.uploadPreset);
form.append('signature', signature);
form.append('source', 'uw');
const uploadUrl = `https://api.cloudinary.com/v1_1/${config.cloudName}/auto/upload`;
try {
const response = await client.post(uploadUrl, form, {
headers: { ...form.getHeaders() }
});
return response.data;
} catch (error) {
throw new Error(`Upload gagal: ${error.response?.data?.error?.message || error.message}`);
}
}
const upscale = {
process: async (url) => {
try {
// 1. Download source image
const imgRes = await axios.get(url, { responseType: 'arraybuffer' });
const imgBuffer = Buffer.from(imgRes.data);
// 2. Get Config
const config = await getDynamicConfig();
// 3. Auth
const timestamp = Math.floor(Date.now() / 1000);
const signature = await getSignature(config, timestamp);
// 4. Upload to Cloudinary
const uploadResult = await uploadImage(config, signature, timestamp, imgBuffer);
// 5. Construct URL
// Parameter Transformasi Cloudinary: e_upscale, q_auto, f_auto
const transformation = 'e_upscale,q_auto,f_auto';
const cloudinaryUrl = `https://res.cloudinary.com/${config.cloudName}/image/upload/${transformation}/${uploadResult.public_id}`;
// 6. Download Result
const resultRes = await axios.get(cloudinaryUrl, { responseType: 'arraybuffer' });
const resultBuffer = Buffer.from(resultRes.data);
// 7. Upload to Public Server (Puruh2o / tmp)
const publicUrl = await uploadToTmp(resultBuffer, `upscale-${Date.now()}.jpg`);
return {
success: true,
image: publicUrl
};
} catch (error) {
return {
success: false,
error: error.message
};
}
}
};
module.exports = { upscale };
---
// FILE: lib\uploader.js
const axios = require('axios');
const FormData = require('form-data');
const https = require('https');
const { encrypt } = require('./crypto');
/**
* Upload file via raw multipart HTTP request
*/
function rawMultipartUpload(hostname, path, buffer, filename, fieldName = 'file') {
return new Promise((resolve, reject) => {
const boundary = '----Boundary' + Math.random().toString(36).slice(2, 16);
const header = Buffer.from(
`--${boundary}\r\n` +
`Content-Disposition: form-data; name="${fieldName}"; filename="${filename}"\r\n` +
`Content-Type: application/octet-stream\r\n\r\n`
);
const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
const body = Buffer.concat([header, buffer, footer]);
const options = {
hostname,
path,
method: 'POST',
headers: {
'Content-Type': `multipart/form-data; boundary=${boundary}`,
'Content-Length': body.length,
'User-Agent': 'Mozilla/5.0'
},
timeout: 120000
};
const req = https.request(options, (res) => {
let data = '';
res.on('data', chunk => data += chunk.toString());
res.on('end', () => {
if (res.statusCode >= 200 && res.statusCode < 300) {
resolve(data.trim());
} else {
reject(new Error(`HTTP ${res.statusCode}: ${data.trim()}`));
}
});
});
req.on('error', reject);
req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
req.write(body);
req.end();
});
}
async function uploadToCatbox(buffer, filename) {
const text = await rawMultipartUpload('catbox.moe', '/user/api.php', buffer, filename, 'fileToUpload');
if (!text.startsWith('http')) throw new Error(`Invalid response: ${text}`);
return text;
}
async function uploadToLitterbox(buffer, filename) {
const boundary = '----Boundary' + Math.random().toString(36).slice(2, 16);
const parts = [
Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="reqtype"\r\n\r\nfileupload\r\n`),
Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="time"\r\n\r\n24h\r\n`),
Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="fileToUpload"; filename="${filename}"\r\nContent-Type: application/octet-stream\r\n\r\n`),
buffer,
Buffer.from(`\r\n--${boundary}--\r\n`)
];
const body = Buffer.concat(parts);
return new Promise((resolve, reject) => {
const options = {
hostname: 'litterbox.catbox.moe',
path: '/resources/internals/api.php',
method: 'POST',
headers: {
'Content-Type': `multipart/form-data; boundary=${boundary}`,
'Content-Length': body.length,
'User-Agent': 'Mozilla/5.0'
},
timeout: 120000
};
const req = https.request(options, (res) => {
let data = '';
res.on('data', chunk => data += chunk.toString());
res.on('end', () => {
const text = data.trim();
if (text.startsWith('http')) resolve(text);
else reject(new Error(`HTTP ${res.statusCode}: ${text}`));
});
});
req.on('error', reject);
req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
req.write(body);
req.end();
});
}
async function uploadToTmpfiles(buffer, filename) {
const form = new FormData();
form.append('file', buffer, filename);
const resp = await axios.post('https://tmpfiles.org/api/v1/upload', form, {
headers: { ...form.getHeaders(), 'User-Agent': 'Mozilla/5.0' },
timeout: 60000
});
if (resp.data?.status !== 'success') throw new Error('Tmpfiles upload failed');
return resp.data.data.url.replace(/https?:\/\/(www\.)?tmpfiles\.org\//, 'https://tmpfiles.org/dl/');
}
async function uploadToGofile(buffer, filename) {
// Step 1: Create guest account to get token
let token = null;
try {
const guestRes = await axios.post('https://api.gofile.io/accounts', {}, {
headers: { 'User-Agent': 'Mozilla/5.0' },
timeout: 30000
});
if (guestRes.data?.status === 'ok') {
token = guestRes.data.data.token;
}
} catch (e) {
// If guest account creation fails, proceed without token
}
// Step 2: Upload file
const form = new FormData();
form.append('file', buffer, filename);
const headers = { ...form.getHeaders(), 'User-Agent': 'Mozilla/5.0' };
if (token) headers['Authorization'] = 'Bearer ' + token;
const resp = await axios.post('https://store3.gofile.io/uploadFile', form, {
headers,
timeout: 120000
});
if (resp.data?.status !== 'ok') throw new Error('Gofile upload failed: ' + (resp.data?.status || 'unknown'));
const downloadPage = resp.data.data.downloadPage;
const contentCode = resp.data.data.code || downloadPage.split('/').pop();
// Step 3: Get direct download URL via content API
if (token && contentCode) {
try {
const contentRes = await axios.get('https://api.gofile.io/contents/' + contentCode, {
headers: {
'Authorization': 'Bearer ' + token,
'User-Agent': 'Mozilla/5.0'
},
timeout: 30000
});
if (contentRes.data?.status === 'ok' && contentRes.data.data) {
const data = contentRes.data.data;
// If it's a folder with children, get the first file's link
if (data.children) {
const children = Object.values(data.children);
if (children.length > 0 && children[0].link) {
return children[0].link;
}
}
// Direct file link
if (data.link) {
return data.link;
}
}
} catch (e) {
// Fall through to scraping approach
}
}
// Step 4: Scrape download page HTML for direct URL
try {
const directUrl = await scrapeGofileDirectUrl(downloadPage, token);
if (directUrl) return directUrl;
} catch (e) {
// Fall through
}
// Step 5: If all else fails, try constructing direct URL from known pattern
// Pattern: https://{server}.gofile.io/download/{contentId}
try {
const serverRes = await axios.get('https://api.gofile.io/servers', {
headers: { 'User-Agent': 'Mozilla/5.0' },
timeout: 10000
});
if (serverRes.data?.status === 'ok' && serverRes.data.data?.servers?.length > 0) {
const server = serverRes.data.data.servers[0].name;
const directUrl = `https://${server}.gofile.io/download/${contentCode}`;
return directUrl;
}
} catch (e) {
// If server list fails, use store3 as default
return `https://store3.gofile.io/download/${contentCode}`;
}
// Ultimate fallback: return the download page
return downloadPage;
}
/**
* Scrape gofile download page HTML to extract direct download URL
*/
async function scrapeGofileDirectUrl(downloadPage, token) {
const headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Language': 'en-US,en;q=0.5',
'Referer': 'https://gofile.io/',
};
if (token) {
headers['Cookie'] = `accountToken=${token}`;
}
const pageRes = await axios.get(downloadPage, {
headers,
maxRedirects: 5,
timeout: 30000
});
const html = pageRes.data;
const contentCode = downloadPage.split('/').pop();
// Pattern 1: Look for direct download URL in JSON-LD or structured data
const jsonLdMatch = html.match(/]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/i);
if (jsonLdMatch) {
try {
const jsonData = JSON.parse(jsonLdMatch[1]);
if (jsonData.url) return jsonData.url;
} catch (e) {}
}
// Pattern 2: Look for window.__INITIAL_STATE__ or similar global variables
const stateMatch = html.match(/window\.__INITIAL_STATE__\s*=\s*({[\s\S]*?});?\s*<\/script>/i);
if (stateMatch) {
try {
const stateData = JSON.parse(stateMatch[1]);
// Navigate state to find download URL
const directUrl = extractUrlFromState(stateData);
if (directUrl) return directUrl;
} catch (e) {}
}
// Pattern 3: Look for any gofile.io/download/ URL in the page
const downloadUrlRegex = /https?:\/\/([a-zA-Z0-9-]+)\.gofile\.io\/download\/[a-zA-Z0-9]+/g;
const matches = html.matchAll(downloadUrlRegex);
for (const match of matches) {
// Verify the URL works
try {
const verifyRes = await axios.head(match[0], {
headers: {
'User-Agent': 'Mozilla/5.0',
'Cookie': headers['Cookie'] || ''
},
maxRedirects: 3,
timeout: 10000
});
if (verifyRes.status >= 200 && verifyRes.status < 400) {
return match[0];
}
} catch (e) {
continue;
}
}
// Pattern 4: Look for meta refresh redirect
const metaRefresh = html.match(/]*url=([^"'\s>]+)/i);
if (metaRefresh) {
return metaRefresh[1];
}
// Pattern 5: Look for download button link patterns
const btnMatch = html.match(/href="([^"]*download[^"]*)"/i);
if (btnMatch && btnMatch[1].includes('gofile.io')) {
return btnMatch[1];
}
return null;
}
function extractUrlFromState(state) {
if (!state || typeof state !== 'object') return null;
// Check common paths in state objects
if (state.downloadUrl) return state.downloadUrl;
if (state.directUrl) return state.directUrl;
if (state.link) return state.link;
if (state.url) return state.url;
// Navigate nested objects
if (state.data) {
if (state.data.downloadUrl) return state.data.downloadUrl;
if (state.data.link) return state.data.link;
if (state.data.directUrl) return state.data.directUrl;
if (state.data.url) return state.data.url;
if (state.data.children) {
const children = Object.values(state.data.children);
if (children.length > 0) {
if (children[0].link) return children[0].link;
if (children[0].downloadUrl) return children[0].downloadUrl;
}
}
}
if (state.props?.pageProps?.data?.link) return state.props.pageProps.data.link;
return null;
}
async function uploadToTmp(buffer, filename = 'file.mp4') {
if (!Buffer.isBuffer(buffer)) throw new Error('Input must be a Buffer.');
const size = buffer.length;
let rawUrl;
let lastError = '';
// Priority 1: Catbox (Direct, 200MB)
if (size <= 200 * 1024 * 1024) {
try { rawUrl = await uploadToCatbox(buffer, filename); } catch (e) { lastError = `catbox: ${e.message}`; }
}
// Priority 2: Litterbox (Direct, 1GB)
if (!rawUrl) {
try { rawUrl = await uploadToLitterbox(buffer, filename); } catch (e) { lastError = `litterbox: ${e.message}`; }
}
// Priority 3: Tmpfiles (Direct, 10MB)
if (!rawUrl && size <= 10 * 1024 * 1024) {
try { rawUrl = await uploadToTmpfiles(buffer, filename); } catch (e) { lastError = `tmpfiles: ${e.message}`; }
}
// Priority 4: Gofile (Direct URL via API/Scraping, Unlimited size)
if (!rawUrl) {
try { rawUrl = await uploadToGofile(buffer, filename); } catch (e) { lastError = `gofile: ${e.message}`; }
}
if (!rawUrl) throw new Error(`All upload services failed. ${lastError}`);
const encrypted = encrypt(rawUrl);
return `/api/media/${encrypted}`;
}
module.exports = { uploadToTmp };
---
// FILE: lib\unlimited.js
const axios = require('axios');
const { v4: uuidv4 } = require('uuid');
const TARGET_URL = 'https://app.unlimitedai.chat/';
const ACTION_ID = '40713570958bf1accf30e8d3ddb17e7948e6c379fa'; // ID Fungsi Server
const CHAT_MODEL = 'chat-model-reasoning'; // Model default
function parseNextJsStream(chunk) {
const lines = chunk.toString().split('\n');
let cleanText = '';
for (const line of lines) {
if (line.includes('"diff":[0,')) {
try {
const jsonStartIndex = line.indexOf('{');
if (jsonStartIndex !== -1) {
const jsonStr = line.substring(jsonStartIndex);
const data = JSON.parse(jsonStr);
if (data.diff && Array.isArray(data.diff) && data.diff[0] === 0) {
cleanText += data.diff[1];
}
}
} catch (e) {
// Abaikan error parsing
}
}
}
return cleanText;
}
async function* chatStream(message) {
const HEADERS = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
'Content-Type': 'text/plain;charset=UTF-8',
'Next-Action': ACTION_ID,
'Next-Router-State-Tree': '%5B%22%22%2C%7B%22children%22%3A%5B%22(chat)%22%2C%7B%22children%22%3A%5B%22page%22%2C%7B%7D%5D%7D%5D%7D%2Cnull%2Cnull%2Ctrue%5D',
'Origin': 'https://app.unlimitedai.chat',
'Referer': 'https://app.unlimitedai.chat/',
};
const chatId = uuidv4();
const messageId = uuidv4();
const now = new Date();
const messages = [
{
id: messageId,
role: "user",
content: message,
parts: [{ type: "text", text: message }],
createdAt: now
}
];
const payloadArg = {
chatId: chatId,
messages: messages,
selectedChatModel: CHAT_MODEL,
selectedCharacter: null,
selectedStory: null,
turnstileToken: undefined
};
const payload = JSON.stringify([payloadArg]);
try {
const response = await axios.post(TARGET_URL, payload, {
headers: HEADERS,
responseType: 'stream'
});
for await (const chunk of response.data) {
const text = parseNextJsStream(chunk);
if (text) yield text;
}
} catch (error) {
throw new Error(error.response?.data ? 'API Unlimited Error' : error.message);
}
}
module.exports = { chatStream };
---
// FILE: lib\unblur.js
const axios = require('axios');
const FormData = require('form-data');
const crypto = require('crypto');
/**
* AI Unblur Processor with Proxy Fallback and Exponential Backoff
*/
function generateRandomSerial() {
return crypto.randomBytes(16).toString('hex');
}
const CONFIG = {
PRODUCT_CODE: '067003',
PROXY_PREFIX: 'https://vercel-api-beta-red.vercel.app/api/fetch?get=',
TARGET_BASE: 'https://api.unblurimage.ai/api/imgupscaler/v2/image-upscaler-v2'
};
async function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
/**
* Custom request handler with proxy fallback logic and backoff
*/
async function requestWithBackoff(method, path, data = null, headers = {}, retryCount = 0) {
// Attempt 0 (retryCount 0) uses Proxy, further attempts go direct
const useProxy = retryCount === 0;
const url = (useProxy ? CONFIG.PROXY_PREFIX : '') + CONFIG.TARGET_BASE + path;
try {
const response = await axios({
method,
url,
data,
headers: {
...headers,
'origin': 'https://unblurimage.ai',
'referer': 'https://unblurimage.ai/',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
},
timeout: 40000
});
return response.data;
} catch (error) {
// Max 3 attempts (1 proxy, 2 direct with backoff)
if (retryCount < 2) {
const waitTime = Math.pow(2, retryCount) * 2000; // 2s, 4s
await sleep(waitTime);
return requestWithBackoff(method, path, data, headers, retryCount + 1);
}
throw error;
}
}
const unblur = {
process: async (imageUrl) => {
try {
const currentSerial = generateRandomSerial();
// 1. Download source image
const imgRes = await axios.get(imageUrl, { responseType: 'arraybuffer' });
const imgBuffer = Buffer.from(imgRes.data);
// 2. Create Job (Upload)
const form = new FormData();
form.append('original_image_file', imgBuffer, { filename: 'input.jpg' });
const createRes = await requestWithBackoff('POST', '/create-job', form, {
...form.getHeaders(),
'product-serial': currentSerial,
'product-code': CONFIG.PRODUCT_CODE
});
if (createRes.code !== 100000) {
throw new Error(`Server Error: ${createRes.message?.en || 'Unknown'}`);
}
const jobId = createRes.result.job_id;
// 3. Polling for result
let isDone = false;
let resultUrl = null;
let attempts = 0;
while (!isDone && attempts < 30) {
const statusRes = await requestWithBackoff('GET', `/get-job/${jobId}`, null, {
'product-serial': currentSerial
});
if (statusRes.code === 100000 && statusRes.result.output_url) {
resultUrl = statusRes.result.output_url;
isDone = true;
} else if (statusRes.code === 300006) {
// Still processing
attempts++;
await sleep(3000);
} else {
throw new Error(`Polling Error: ${statusRes.message?.en || 'Unknown'}`);
}
}
if (!resultUrl) throw new Error("Processing timeout.");
// 4. Download result
const resultRes = await axios.get(resultUrl, { responseType: 'arraybuffer' });
return Buffer.from(resultRes.data);
} catch (error) {
throw error;
}
}
};
module.exports = unblur;
---
// FILE: lib\tsundere.js
const axios = require('axios');
function generateFakeIP() {
return Array.from({ length: 4 }, () => Math.floor(Math.random() * 255)).join('.');
}
async function generateTsundereTTS(text) {
const url = 'https://api.screenapp.io/v2/proxy/google/tts';
const fakeIP = generateFakeIP();
const payload = {
"input": text,
"model": "gemini-2.5-flash-tts",
"voice": "Kore",
"language_code": "id-ID",
"response_format": "mp3",
"speaking_rate": 1.1,
"pitch": 2.5,
"volume_gain_db": 0
};
const headers = {
'authority': 'api.screenapp.io',
'accept': '*/*',
'content-type': 'application/json',
'origin': 'https://screenapp.io',
'referer': 'https://screenapp.io/',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
'x-forwarded-for': fakeIP,
'client-ip': fakeIP,
'via': '1.1 google',
};
try {
const response = await axios({
method: 'post',
url: url,
data: payload,
headers: headers,
responseType: 'arraybuffer'
});
return Buffer.from(response.data);
} catch (error) {
throw new Error(error.response?.data ? `TTS Error: ${error.response.status}` : error.message);
}
}
module.exports = { generateTsundereTTS };
---
// FILE: lib\tiktokV2.js
/***
*** ᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁
*** - TikTok Downloader
*** - Base URL: https://tikdownloader.io
*** - Note: Jangan lupa install cloudscraper
***
*** - Dev: 𝖸𝖺𝖻𝖾𝗌
*** - Contact: t.me/Yabes_Desu
*** - Gmail: yabeskun@gmail.com
*** ᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁᠁
***/
const cloudscraper = require('cloudscraper');
const tiktokDL = async (url, retries = 5) => {
if (!url?.trim()) return { success: false, result: 'URL kosong' };
const req = async (opts) => {
for (let i = 0; i < retries; i++) {
try {
const r = await cloudscraper({ ...opts, cloudflareTimeout: 7000, followAllRedirects: true });
return typeof r === 'string' ? JSON.parse(r) : r;
} catch (e) {
if (i === retries - 1) throw e;
await new Promise(r => setTimeout(r, 2 ** i * 1000));
}
}
};
try {
const { status, data, statusCode, msg } = await req({
uri: 'https://tikdownloader.io/api/ajaxSearch',
method: 'POST',
form: { q: url }
});
if (statusCode === 326) return { success: false, result: msg || 'Link invalid' };
if (status !== 'ok' || !data) return { success: false, result: 'Gagal ambil data' };
const html = data.replace(/&(?:amp|lt|gt|quot|#x27|#39|#x2F|nbsp|#xA0|#160|#(\d+)|#x([0-9a-fA-F]+));/gi,
(_, dec, hex) => dec ? String.fromCharCode(dec) : hex ? String.fromCharCode(parseInt(hex, 16)) :
{ '&':'&','<':'<','>':'>','"':'"',''':"'",''':"'",'/':'/',' ':' ',' ':' ',' ':' ' }[_] || _);
const $ = s => (html.match(s) || [])[1]?.trim();
const isPhoto = html.includes('photo-list');
const downloads = isPhoto
? [...html.matchAll(/href="([^"]+)"[^>]*btn-premium[^>]*>[\s\S]*?Download Image/g)].map((m, i) => ({ type: `Image ${i+1}`, url: m[1] }))
.concat((html.match(/href="([^"]+dl\.snapcdn\.app[^"]+)".*?Download MP3/) || []).slice(1).map(u => ({ type: 'MP3', url: u })))
: [...html.matchAll(/href="([^"]+)"[^>]*tik-button-dl[^>]*>([\s\S]*?)<\/a>/g)].map(m => ({
type: m[2].replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim(),
url: m[1]
}));
if (!downloads.length) return { success: false, result: 'Tidak ada link download' };
return {
success: true,
result: {
type: isPhoto ? 'photo' : 'video',
title: $(/]*>([^<]+)<\/h3>/),
thumbnail: $(/]*(?:class="[^"]*image-tik[^"]*"|)/),
downloads
}
};
} catch (e) {
return { success: false, result: e.message };
}
};
module.exports = { tiktokDL };
---
// FILE: lib\tiktokchart.js
const cloudscraper = require('cloudscraper');
/**
* Scrape TikTok chart Indonesia from Soundcharts
* @returns {Promise} Array of {position, title, artist, songId}
*/
async function tiktokChartIndonesia() {
const url = 'https://soundcharts.com/en/charts/tiktok/indonesia';
const html = await cloudscraper.get({ uri: url, timeout: 30000 });
// Find the JSON-LD script containing ItemList (chart data)
const match = html.match(
/]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi
);
if (!match) throw new Error('No JSON-LD scripts found');
let chartData = null;
for (const scriptTag of match) {
const jsonMatch = scriptTag.replace(/<\/?script[^>]*>/gi, '');
try {
const parsed = JSON.parse(jsonMatch);
if (
parsed['@type'] === 'ItemList' &&
parsed.name &&
parsed.name.includes('TikTok')
) {
chartData = parsed;
break;
}
} catch (_) {
// skip invalid JSON
}
}
if (!chartData || !chartData.itemListElement) {
throw new Error('Could not find TikTok chart data in page');
}
const results = chartData.itemListElement.map(item => {
const song = item.item;
const position = item.position;
const title = song.name;
const artist = song.byArtist ? song.byArtist.name : 'Unknown';
const songId = song.url ? song.url.split('/').pop() : '';
return {
position,
title,
artist,
songId
};
});
return results;
}
module.exports = { tiktokChartIndonesia };
---
// FILE: lib\tiktok.js
// Memindahkan file dari server/api/lib/tiktok.js ke lib/tiktok.js
const axios = require('axios');
const TIKTOK_API_BASE = 'https://www.tikwm.com';
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
async function download(url) {
if (!url || typeof url !== 'string') {
throw new Error('URL TikTok tidak valid.');
}
const submitResponse = await axios.post(`${TIKTOK_API_BASE}/api/video/task/submit`, new URLSearchParams({
url: url,
web: '1'
}), {
headers: {
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
}
});
if (submitResponse.data.code !== 0 || !submitResponse.data.data.task_id) {
throw new Error(`Gagal memulai tugas unduhan: ${submitResponse.data.msg || 'Respons tidak valid'}`);
}
const taskId = submitResponse.data.data.task_id;
const maxAttempts = 15;
for (let i = 0; i < maxAttempts; i++) {
await sleep(1000);
const resultResponse = await axios.get(`${TIKTOK_API_BASE}/api/video/task/result`, {
params: { task_id: taskId }
});
const resultData = resultResponse.data;
if (resultData.code !== 0) {
continue;
}
if (resultData.data && resultData.data.status === 2) {
return resultData.data;
}
if (resultData.data && resultData.data.status > 2) {
throw new Error(`Proses unduhan gagal dengan status: ${resultData.data.msg || 'Tidak diketahui'}`);
}
}
throw new Error('Gagal mendapatkan hasil unduhan setelah beberapa kali percobaan (timeout).');
}
module.exports = { download };
---
// FILE: lib\tempService.js
const pool = require('./db');
const { v4: uuidv4 } = require('uuid');
// Ensure table exists
const ensureTable = async () => {
const query = `
CREATE TABLE IF NOT EXISTS temp_store (
id UUID PRIMARY KEY,
data JSONB NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
`;
await pool.query(query);
};
const tempService = {
save: async (data, ttlMinutes = 30) => {
await ensureTable();
const id = uuidv4();
// Set expiry time
const expiresAt = new Date(Date.now() + ttlMinutes * 60000);
const query = 'INSERT INTO temp_store (id, data, expires_at) VALUES ($1, $2, $3)';
await pool.query(query, [id, data, expiresAt]);
return id;
},
get: async (id) => {
await ensureTable();
// Fetch only if not expired
const query = 'SELECT data FROM temp_store WHERE id = $1 AND expires_at > NOW()';
const result = await pool.query(query, [id]);
if (result.rows.length === 0) return null;
return result.rows[0].data;
}
};
module.exports = tempService;
---
// FILE: lib\svara.js
// Memindahkan file dari server/api/lib/svara.js ke lib/svara.js
// Credit: Daffa dari nbscript (https://whatsapp.com/channel/0029VbBmAXAHAdNWOpWN531c)
const axios = require('axios');
const svara = {
api: {
base: 'https://svara.aculix.net',
endpoint: {
generate: '/generate-speech',
},
},
headers: {
'user-agent': 'NB Android/1.0.0',
'accept-encoding': 'gzip',
'content-type': 'application/json',
},
cid: new Uint8Array([
0x24, 0x52, 0x43, 0x41, 0x6e, 0x6f, 0x6e, 0x79,
0x6d, 0x6f, 0x75, 0x73, 0x49, 0x44, 0x3a, 0x31,
0x33, 0x65, 0x38, 0x37, 0x35, 0x33, 0x61, 0x65,
0x36, 0x31, 0x39, 0x34, 0x63, 0x37, 0x62, 0x39,
0x32, 0x37, 0x33, 0x32, 0x64, 0x36, 0x36, 0x64,
0x37, 0x30, 0x32, 0x33, 0x30, 0x37, 0x32
]),
auth: new Uint8Array([
0x77, 0x76, 0x65, 0x62, 0x6e, 0x79, 0x75, 0x36, 0x36, 0x36, 0x38, 0x37, 0x35, 0x36, 0x68, 0x34,
0x35, 0x67, 0x66, 0x65, 0x63, 0x64, 0x66, 0x65, 0x67, 0x6e, 0x68, 0x6d, 0x75, 0x36, 0x6b, 0x6a,
0x35, 0x68, 0x36, 0x34, 0x67, 0x35, 0x33, 0x66, 0x76, 0x72, 0x62, 0x67, 0x6e, 0x79, 0x35
]),
voiceX: {
'alloy': 'af_alloy', 'aoede': 'af_aoede', 'bella': 'af_bella', 'heart': 'af_heart',
'jessica': 'af_jessica', 'kore': 'af_kore', 'nicole': 'af_nicole', 'nova': 'af_nova',
'river': 'af_river', 'sarah': 'af_sarah', 'sky': 'af_sky',
'adam': 'am_adam', 'echo': 'am_echo', 'eric': 'am_eric', 'fenrir': 'am_fenrir',
'liam': 'am_liam', 'michael': 'am_michael', 'onyx': 'am_onyx', 'puck': 'am_puck',
'santa': 'am_santa',
'alice': 'bf_alice', 'emma': 'bf_emma', 'isabella': 'bf_isabella', 'lily': 'bf_lily',
'daniel': 'bm_daniel', 'fable': 'bm_fable', 'george': 'bm_george', 'lewis': 'bm_lewis',
'anaya': 'hf_alpha', 'riya': 'hf_beta', 'arjun': 'hm_omega', 'kabir': 'hm_psi',
'dora': 'ef_dora',
'santiago': 'em_alex', 'noel': 'em_santa',
'siwis': 'ff_siwis',
'aiko': 'jf_alpha', 'gongitsune': 'jf_gongitsune', 'nezumi': 'jf_nezumi',
'tebukuro': 'jf_tebukuro', 'kumo': 'jm_kumo',
'sara': 'if_sara', 'nicola': 'im_nicola',
'doras': 'pf_dora',
'alex': 'pm_alex', 'antonio': 'pm_santa',
'xiaobei': 'zf_xiaobei', 'xiaoni': 'zf_xiaoni', 'xiaoxiao': 'zf_xiaoxiao',
'xiaoyi': 'zf_xiaoyi', 'yunjian': 'zm_yunjian', 'yunxi': 'zm_yunxi',
'yunxia': 'zm_yunxia', 'yunyang': 'zm_yunyang'
},
getVoiceId: function(vn) {
const i = vn.toLowerCase().trim();
return this.voiceX[i];
},
generate: async function(text, vn) {
if (!text?.trim()) {
return {
success: false,
code: 400,
author: 'PuruBoy x Daffa (nbscript)',
result: {
error: 'Parameter `text` tidak boleh kosong.'
},
};
}
if (text.length > 300) {
return {
success: false,
code: 413,
author: 'PuruBoy x Daffa (nbscript)',
result: {
error: 'Panjang `text` maksimal 300 karakter.'
},
};
}
const voiceId = this.getVoiceId(vn);
if (!voiceId) {
const av = Object.keys(this.voiceX).join(', ');
return {
success: false,
code: 422,
author: 'PuruBoy x Daffa (nbscript)',
result: {
error: `Nama voice "${vn}" tidak valid. Pilih salah satu dari: ${av}`
},
};
}
const decoder = new TextDecoder();
const ciu = decoder.decode(this.cid);
const toket = decoder.decode(this.auth);
const body = {
customerId: ciu,
text: text,
voice: voiceId,
};
try {
const res = await axios.post(
`${this.api.base}${this.api.endpoint.generate}`,
body,
{
headers: {
...this.headers,
authorization: toket
}
}
);
const { outputUrl } = res.data;
return {
success: true,
code: 200,
author: 'PuruBoy x Daffa (nbscript)',
result: {
audio: outputUrl,
voice: voiceId,
text_length: text.length,
},
};
} catch (err) {
return {
success: false,
code: err.response?.status || 500,
author: 'PuruBoy x Daffa (nbscript)',
result: {
error: err.message || 'Terjadi kesalahan internal.',
},
};
}
},
};
module.exports = { svara };
---
// FILE: lib\stabilizer.js
const axios = require('axios');
const FormData = require('form-data');
/**
* AI Video Stabilizer Service
* Updated logic based on HAR data: uses URL submission instead of direct buffer upload.
*/
const stabilizer = {
/**
* Create a stabilization job on the remote server
*/
createJob: async (videoUrl) => {
try {
const form = new FormData();
form.append('url', videoUrl);
const response = await axios.post('https://nirkyy-stabilizer.hf.space/api/stabilize', form, {
headers: {
...form.getHeaders(),
'User-Agent': 'Mozilla/5.0 (Linux; Android 10; RMX2185 Build/QP1A.190711.020) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.7632.120 Mobile Safari/537.36',
'origin': 'https://nirkyy-stabilizer.hf.space',
'referer': 'https://nirkyy-stabilizer.hf.space/',
'x-requested-with': 'mark.via.gp'
}
});
return response.data; // { job_id: "...", message: "..." }
} catch (error) {
throw new Error(`Stabilizer Job Error: ${error.response?.data?.message || error.message}`);
}
},
/**
* Check status of a specific job
*/
checkStatus: async (jobId) => {
try {
const response = await axios.get(`https://nirkyy-stabilizer.hf.space/api/status/${jobId}`, {
headers: {
'User-Agent': 'Mozilla/5.0 (Linux; Android 10; RMX2185 Build/QP1A.190711.020) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.7632.120 Mobile Safari/537.36',
'x-requested-with': 'mark.via.gp',
'referer': 'https://nirkyy-stabilizer.hf.space/'
}
});
return response.data; // { status: "process" } or { status: "success", url: "..." }
} catch (error) {
throw new Error(`Stabilizer Status Error: ${error.response?.data?.message || error.message}`);
}
}
};
module.exports = stabilizer;
---
// FILE: lib\soundcloudSearch.js
const axios = require("axios");
const qs = require("querystring");
let cachedID = null;
// Step 1: Ambil client_id dengan cara modern
async function getClientID() {
if (cachedID) return cachedID;
const homepage = await axios.get("https://soundcloud.com");
const scriptUrls = [...homepage.data.matchAll(/
