index.js

import bytes from 'bytes'
import cp from 'child_process'
import express from 'express'
import favicon from 'serve-favicon'
import fs from 'fs'
import morgan from 'morgan'
import os from 'os'
import path from 'path'
import playwright from 'playwright'
import PDFDocument from 'pdfkit'
import sharp from 'sharp'
import util from 'util'
import yts from 'yt-search'

const utils = {
	getBrowser: (...opts) => playwright.chromium.launch({
		args: [
			'--incognito', '--single-process',
			'--no-sandbox', '--no-zygote', '--no-cache'
		],
		executablePath: process.env.CHROME_BIN,
		headless: true,
		...opts
	}),
	// from https://github.com/petersolopov/carbonara
	fetchCarbonaraAPI: async (code, opts = {}) => {
		let resp = await utils.fetchPOST('https://carbonara.solopov.dev/api/cook', JSON.stringify({ code, ...opts }), {
			headers: { 'Content-Type': 'application/json' }
		})
		if (!resp.ok) {
			let content = resp.headers.get('content-type')
			if (/json$/.test(content)) {
				let json = await resp.json()
				throw json.error || 'An error occurred'
			}
			throw resp.statusText
		}
		
		let img = await resp.arrayBuffer()
		const output = `${tmpDir}/${utils.randomName('.png')}`
		await fs.promises.writeFile(output, Buffer.from(img))
		return output
	},
	fetchCobaltAPI: async (url, opts = {}) => (
		await utils.fetchPOST('https://cobalt-7.kwiatekmiki.com/api/json', JSON.stringify({ url, ...opts }), {
			headers: { Accept: 'application/json', 'Content-Type': 'application/json' }
		})
	).json(),
	fetchPOST: (url, body, opts = {}) => fetch(url, { method: 'POST', body, ...opts }),
	formatSize: (n) => bytes(+n, { unitSeparator: ' ' }),
	generateBrat: async (text) => {
		const browser = await utils.getBrowser()
		try {
			const page = await browser.newPage()
			await page.goto('https://www.bratgenerator.com/')
			await page.click('#toggleButtonWhite')
			await page.locator('#textInput').fill(text)
			const output = `${tmpDir}/${utils.randomName('.jpg')}`
			const ss = await page.locator('#textOverlay')
				.screenshot({ path: output })
			return output
		} catch (e) {
			throw e
		} finally {
			await browser.close()
		}
	},
	getError: (e) => String(e).startsWith('[object ') ? 'Internal Server Error' : String(e),
	isBase64: (str) => {
		try {
			return btoa(atob(str)) === str
		} catch {
			return false
		}
	},
	isTrue: (str) => [true, 'true'].includes(str),
	randomIP: () => [...new Array(4)].map(() => ~~(Math.random() * 256)).join('.'),
	randomName: (str = '') => (Math.random().toString(36).slice(2) + str),
	toPDF: (urls, opts = {}) => new Promise(async (resolve, reject) => {
		try {
			const doc = new PDFDocument({ margin: 0, size: 'A4' })
			const buffs = []
				
			for (let x = 0; x < urls.length; x++) {
				if (!/https?:\/\//.test(urls[x])) continue
				const url = new URL(urls[x])
				let image = await fetch(url.toString(), { headers: { referer: url.origin } })
				if (!image.ok) continue
				
				const type = image.headers.get('content-type')
				if (!/image/.test(type)) continue
				image = Buffer.from(await image.arrayBuffer())
				if (/(gif|webp)$/.test(type)) image = await sharp(image).png().toBuffer()
				
				doc.image(image, 0, 0, { fit: [595.28, 841.89], align: 'center', valign: 'center', ...opts })
				if (urls.length != x + 1) doc.addPage()
			}
			
			doc.on('data', (chunk) => buffs.push(chunk))
			doc.on('end', () => resolve(Buffer.concat(buffs)))
			doc.on('error', (err) => reject(err))
			doc.end()
		} catch (e) {
			console.log(e)
			reject(e)
		}
	}),
	// from https://github.com/Nurutomo/wabot-aq/blob/master/lib/y2mate.js#L15
	ytIdRegex: /(?:http(?:s|):\/\/|)(?:(?:www\.|)?youtube(?:\-nocookie|)\.com\/(?:shorts\/)?(?:watch\?.*(?:|\&)v=|embed\/|live\/|v\/)?|youtu\.be\/)([-_0-9A-Za-z]{11})/,
}

const app = express()
const tmpDir = os.tmpdir()

app.set('json spaces', 4)
app.use(express.json({ limit: '200mb' }))
app.use(express.urlencoded({ extended: true, limit: '200mb' }))
app.use(favicon(path.join(import.meta.dirname, 'favicon.ico')))
app.use(morgan('combined'))

app.use((req, __, next) => {
	// clear tmp
	for (let file of fs.readdirSync(tmpDir)) {
		file = `${tmpDir}/${file}`
		const stat = fs.statSync(file)
		const exp = Date.now() - stat.mtimeMs >= 1000 * 60 * 30
		if (stat.isFile() && exp) {
			console.log('Deleted file', file)
			fs.unlinkSync(file)
		}
	}
	req.allParams = Object.assign(req.query, req.body)
	req.headers['User-Agent'] = 'WhatsApp/1.2.3'
	next()
})

app.use('/file', express.static(tmpDir))

app.all('/', (_, res) => {
	const status = {}
	status['diskUsage'] = cp.execSync('du -sh').toString().split('M')[0] + ' MB'
	
	const used = process.memoryUsage()
	for (let x in used) status[x] = utils.formatSize(used[x])
	
	const totalmem = os.totalmem()
	const freemem = os.freemem()
	status['memoryUsage'] = `${utils.formatSize(totalmem - freemem)} / ${utils.formatSize(totalmem)}`
	
	res.json({
		message: 'Hello World!',
		uptime: new Date(process.uptime() * 1000).toUTCString().split(' ')[4],
		status
	})
})

app.all(/^\/(brat|carbon)/, async (req, res) => {
	if (!['GET', 'POST'].includes(req.method)) return res.status(405).json({ success: false, message: 'Method Not Allowed' })
	
	try {
		const obj = req.allParams
		const isBrat = req.params[0] === 'brat'
		if (isBrat && !obj.text) {
			return res.status(400).json({ success: false, message: 'Required parameter \'text\'' })
		} else if (!isBrat && !(obj.code || obj.text)) {
			return res.status(400).json({ success: false, message: 'Required parameter \'code\'' })
		}
		
		const image = isBrat ?
			await utils.generateBrat(obj.text) :
			utils.fetchCarbonaraAPI(obj.code || obj.text, obj)
		const resultUrl = `https://${req.hostname}/${image.replace(tmpDir, 'file')}`
		utils.isTrue(obj.json) ?
			res.json({ success: true, result: resultUrl }) :
		res[utils.isTrue(obj.raw) ? 'send' : 'redirect'](resultUrl)
	} catch (e) {
		console.log(e)
		res.status(500).json({ error: true, message: utils.getError(e) })
	}
})

app.all('/topdf', async (req, res) => {
	if (req.method !== 'POST') return res.status(405).json({ success: false, message: 'Method Not Allowed' })
	
	try {
		const { images: urls, json, raw } = req.body
		if (!urls) return res.status(400).json({ success: false, message: 'Payload \'images\' requires an array of urls' })
		if (!Array.isArray(urls)) urls = [urls]
		
		const bufferPDF = await utils.toPDF(urls)
		if (!bufferPDF.length) return res.status(400).json({ success: false, message: 'Can\'t convert to pdf' })
		
		const fileName = utils.randomName('.pdf')
		await fs.promises.writeFile(`${tmpDir}/${fileName}`, bufferPDF)
		
		const resultUrl = `https://${req.hostname}/file/${fileName}`
		utils.isTrue(json) ?
			res.json({ success: true, result: resultUrl }) :
		res[utils.isTrue(raw) ? 'send' : 'redirect'](resultUrl)
	} catch (e) {
		console.log(e)
		res.status(500).json({ error: true, message: utils.getError(e) })
	}
})

app.all(/^\/webp2(gif|mp4|png)/, async (req, res) => {
	if (req.method !== 'POST') return res.status(405).json({ success: false, message: 'Method Not Allowed' })
	
	try {
		const { file, json, raw } = req.body
		if (!file) return res.status(400).json({ success: false, message: 'Payload \'file\' requires base64 string' })
		if (!utils.isBase64(file)) return res.status(400).json({ success: false, message: 'Invalid base64 format' })
		
		const type = req.params[0]
		if (type === 'png') {
			const fileName = utils.randomName('.png')
			const fileBuffer = await sharp(Buffer.from(file, 'base64')).png().toBuffer()
			await fs.promises.writeFile(`${tmpDir}/${fileName}`, fileBuffer)
			
			const resultUrl = `https://${req.hostname}/file/${fileName}`
			utils.isTrue(json) ?
				res.json({ success: true, result: resultUrl }) :
			res[utils.isTrue(raw) ? 'send' : 'redirect'](resultUrl)
			return
		}
		
		const fileName = utils.randomName('.webp')
		const filePath = `${tmpDir}/${fileName}`
		await fs.promises.writeFile(filePath, Buffer.from(file, 'base64'))
		
		const exec = util.promisify(cp.exec).bind(cp)
		await exec(`convert ${filePath} ${filePath.replace('webp', 'gif')}`)
		
		let resultUrl
		if (type === 'gif') resultUrl = `https://${req.hostname}/file/${fileName.replace('webp', 'gif')}`
		else {
			await exec(`ffmpeg -i ${filePath.replace('webp', 'gif')} -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" ${filePath.replace('webp', 'mp4')}`)
			resultUrl = `https://${req.hostname}/file/${fileName.replace('webp', 'mp4')}`
		}
		
		utils.isTrue(json) ?
			res.json({ success: true, result: resultUrl }) :
		res[utils.isTrue(raw) ? 'send' : 'redirect'](resultUrl)
	} catch (e) {
		console.log(e)
		res.status(500).json({ error: true, message: utils.getError(e) })
	}
})

// /yt /yt/dl /yt/download /yt/search /youtube/dl /youtube/download /youtube/search
app.all(/^\/y(outube|t)(\/(d(ownload|l)|search)?)?/, async (req, res) => {
	if (!['GET', 'POST'].includes(req.method)) return res.status(405).json({ success: false, message: 'Method Not Allowed' })
	
	try {
		const type = req.params[2]
		const obj = req.allParams
		if (type === 'search') {
			if (!obj.query) return res.status(400).json({ success: false, message: 'Required parameter \'query\'' })
			
			const result = await yts(obj)
			if (!(result.all?.length || result?.url)) return res.status(400).json({ success: false, message: 'Video unavailable' })
			
			res.json({ success: true, result })
			return
		} else if (['dl', 'download'].includes(type)) {
			if (!obj.url) return res.status(400).json({ success: false, message: 'Required parameter \'url\'' })
			if (!utils.ytIdRegex.test(obj.url)) return res.status(400).json({ success: false, message: 'Invalid url' })
			
			const payload = obj
			if (obj.type === 'audio') {
				payload.isAudioOnly = true
				// payload.audioBitrate = obj.quality || '128'
			} else {
				payload.vQuality = obj.quality || '720'
			}
			// nembak lagi woila
			const result = await utils.fetchCobaltAPI(obj.url, payload)
			if (result.status === 'error') return res.status(400).json({ success: false, message: 'An error occurred' })
			res.redirect(result.url)
			return
		}
	
		if (!obj.query) return res.status(400).json({ success: false, message: 'Required parameter \'query\'' })
		
		let result = await yts(utils.ytIdRegex.test(obj.query) ? { videoId: utils.ytIdRegex.exec(obj.query)[1] } : obj.query)
		result = result.videos ? result.videos[0] : result
		if (!result?.url) return res.status(400).json({ success: false, message: 'Video unavailable' })
		
		const dlUrl = `https://${req.hostname}/yt/dl?url=${result.url}`
		const download = { audio: `${dlUrl}&type=audio`, video: `${dlUrl}&type=video` }
		res.json({
			success: true,
			result: { ...result, download }
		})
	} catch (e) {
		console.log(e)
		res.status(500).json({ error: true, message: utils.getError(e) })
	}
})

// app.use((req, res, next) => {})

app.listen(7860, () => console.log('App running on port 7860'))