index.js

const os = require('os')
const bytes = require('bytes')
const sharp = require('sharp')
const morgan = require('morgan')
const express = require('express')
const PDFDocument = require('pdfkit')
const axios = require("axios")
const FormData = require("form-data")
const ytdl = require('ytdl-core')
const Jimp = require('jimp')
const fileType = require("file-type")

//const Stress = require('./lib/ddos.js');
//const { BingChat } = (await import("bing-chat")).default
const { acytoo, chatgpt_4 } = require("./lib/chatgpt.js")
const { sss_instagram, gramvio } = require("./lib/instagram.js")
const { allToJpg } = require("./lib/convertFormat.js")
const apikey = "@SadTeam77"

const app = express()
app.set('json spaces', 4)
app.use(morgan('dev'))
app.use(express.json({ limit: "500mb" }))
app.use(express.urlencoded({ limit: '500mb', extended: true }))
app.use((req, res, next) => {
  next()
})

app.all('/', (req, res) => {
	const status = {}
	const used = process.memoryUsage()
	for (let key in used) status[key] = formatSize(used[key])
	
	const totalmem = os.totalmem()
	const freemem = os.freemem()
	status.memoryUsage = `${formatSize(totalmem - freemem)} / ${formatSize(totalmem)}`

    console.log("YOUR IP: " + req.ip)
	
	res.json({
		creator: "@SadTeams",
		message: 'Hello World!!',
		uptime: new Date(process.uptime() * 1000).toUTCString().split(' ')[4],
		status
	})
})

app.post('/imagetopdf', async (req, res) => {
	try {
		console.log(req.body)
		const { images } = req.body
		if (!images) return res.json({ success: false, message: 'Required an array image url' })
		
		const buffer = await toPDF(images)
		res.setHeader('Content-Disposition', `attachment; filename=${Math.random().toString(36).slice(2)}.pdf`)
		res.setHeader('Content-Type', 'application/pdf')
		res.setHeader('Content-Length', buffer.byteLength)
		res.send(buffer)
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})

app.post('/api/chatgpt', async (req, res) => {
	try {
		console.log(req.body)
		const { prompt, model, status } = req.body
		if (!prompt) return res.json({ success: false, message: 'Required an prompt text!' })
        if (!model) return res.json({ success: false, message: 'Required an model version!' })
        if (!status) return res.json({ success: false, message: 'Required an prompt text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        if(model == "gpt-4") {
          const response = await axios.request({
            method: "GET",
            url: "https://aemt.me/gpt4?text=" + prompt
          })
          res.json({
            status: "ok",
            result: response.data.result
          })
        } else if(model == "gpt-3.5") {
          const response = await acytoo(prompt, "gpt-4")
          res.json({
            status: "ok",
            result: response
          })
        } else if(model == "gpt-3") {
          const response = await acytoo(prompt, "gpt-3.5-turbo")
          res.json({
            status: "ok",
            result: response
          })
        }
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/chatgpt2', async (req, res) => {
	try {
		console.log(req.body)
		const { data, prompt, status } = req.body
        if (!data) return res.json({ success: false, message: 'Required an data text!' })
		if (!prompt) return res.json({ success: false, message: 'Required an prompt text!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await axios.request({
          method: "GET",
          url: `https://aemt.me/prompt/gpt?prompt=${data}&text=${prompt}`
        })
        res.json({
          status: "ok",
          result: response.data.result
        })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/toanime', async (req, res) => {
	try {
		console.log(req.body)
		const { url, status } = req.body
        if (!url) return res.json({ success: false, message: 'Required an url!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await axios.request({
          method: "GET",
          url: "https://aemt.me/toanime?url=" + url
        })
        const image = await axios.request({
          method: "GET", 
          url: response.data.url.img_crop_single,
          responseType: "arraybuffer" 
        })
        res.setHeader('Content-Type', 'image/jpeg')
        res.send(image.data)
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/upscaler', async (req, res) => {
	try {
		console.log(req.body)
		const { images, denoise, scale, format, type, status } = req.body
        if (!images) return res.json({ success: false, message: 'Required an images!' })
        if (!denoise) return res.json({ success: false, message: 'Required an denoise!' })
        if (!scale) return res.json({ success: false, message: 'Required an images!' })
        if (!format) return res.json({ success: false, message: 'Required an format size!' })
        if (!type) return res.json({ success: false, message: 'Required an images!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        if (/^(https?|http):\/\//i.test(images)) {
          const data_img = await axios.request({
            method: "GET",
            url: images,
            responseType: "arraybuffer"
          })
          const response = await processImageUpscaler(data_img.data, denoise, scale, format, type)
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else if (images && typeof images == 'string' && isBase64(images)) {
	   	  const response = await processImage(Buffer.from(images, "base64"), denoise, scale, format, type)
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else {
          res.json({
            success: false, message: 'No url or base64 detected!!' 
          })
        }
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})

app.post('/api/img2img', async (req, res) => {
	try {
		console.log(req.body)
		const { images, prompt, status } = req.body
        if (!images) return res.json({ success: false, message: 'Required an images!' })
        if (!promot) return res.json({ succese: false, message: 'Require an Promot text Image!'})
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        if (/^(https?|http):\/\//i.test(images)) {
          const data_img = await axios.request({
            method: "GET",
            url: images,
            responseType: "arraybuffer"
          })
          const response = await processImage2Img(data_img.data, prompt)
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else if (images && typeof images == 'string' && isBase64(images)) {
	   	  const response = await processImage2Img(Buffer.from(images, "base64"), prompt)
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else {
          res.json({
            success: false, message: 'No url or base64 detected!!' 
          })
        }
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/toanime2', async (req, res) => {
	try {
		console.log(req.body)
		const { status, images } = req.body
        if (!images) return res.json({ success: false, message: 'Required an images!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        if (/^(https?|http):\/\//i.test(images)) {
          const data_img = await axios.request({
            method: "GET",
            url: images,
            responseType: "arraybuffer"
          })
          const imageBase64 = Buffer.from(data_img.data, 'binary').toString('base64');
          const response = await processImageAnime(imageBase64);
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else if (images && typeof images == 'string' && isBase64(images)) {
	   	  const response = await processImageAnime(images)
          const type_img = await fileType.fromBuffer(response)
          res.setHeader('Content-Type', type_img.mime)
          res.send(response)
        } else {
          res.json({
            success: false, message: 'No url or base64 detected!!' 
          })
        }
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})

app.post('/api/instagram/stalk', async (req, res) => {
	try {
		console.log(req.body)
		const { username, status } = req.body
        if (!username) return res.json({ success: false, message: 'Required an username text!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await gramvio(username)
        res.json({
          status: "ok",
          result: response
        })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/instagram/download', async (req, res) => {
	try {
		console.log(req.body)
		const { url, status } = req.body
        if (!url) return res.json({ success: false, message: 'Required an url!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await sss_instagram(url)
        res.json({
          status: "ok",
          result: response
        })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/api/youtube/info', async (req, res) => {
	try {
		console.log(req.body)
		const { url, status } = req.body
        if (!url) return res.json({ success: false, message: 'Required an url!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        const videoID = ytdl.getVideoID(url)
        if (!videoID) return res.json({ success: false, message: 'Id Video Not Found!!!' })
		const response = await ytdl.getInfo(videoID)
        res.json({
          success: true,
          result: { ...response }
        })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
/*app.post('/tools/ddos', async (req, res) => {
	try {
		console.log(req.body)
		const { url, interval, mount, status } = req.body
        if (!url) return res.json({ success: false, message: 'Required an url!' })
        if (!interval) return res.json({ success: false, message: 'Required an interval number!' })
        if (!mount) return res.json({ success: false, message: 'Required an mount number!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await Stress.start({
          debug: true,
          url: url,
          interval: interval,
          max: mount,
          proxy: "./proxy.txt"
        })
      res.json({
        status: "ok",
        target: url,
        interval: interval,
        mount: mount,
        response
      })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})*/
app.post('/api/bingchat', async (req, res) => {
	try {
		console.log(req.body)
		const { prompt, status } = req.body
        if (!prompt) return res.json({ success: false, message: 'Required an prompt text!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
		const response = await axios.request({
          method: "GET",
          url: "https://aemt.me/bingai?text=" + prompt
        })
        res.json({
          status: "ok",
          result: response.data.result
        })
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})
app.post('/convert/zombie', async (req, res) => {
	try {
		console.log(req.body)
		const { url, status } = req.body
        if (!url) return res.json({ success: false, message: 'Required an url!' })
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        const resp = await axios.request({
          method: "GET",
          url: "https://aemt.me/converter/zombie?url=" + url
        })
        const response = await axios.request({
          method: "GET",
          url: resp.data.url,
          contentType: "arraybuffer"
        })
        res.setHeader('Content-Type', 'image/jpeg')
        res.send(response.data)
	} catch (e) {
		console.log(e)
		e = String(e)
		res.json({ error: true, message: e === '[object Object]' ? 'Internal Server Error' : e })
	}
})

const PORT = process.env.PORT || 7860
app.listen(PORT, () => {
  console.log('App running on port', PORT)
})                         

function formatSize(num) {
	return bytes(+num || 0, { unitSeparator: ' ' })
}
function isBase64(str) {
	try {
		return btoa(atob(str)) === str
	} catch {
		return false
	}
}
function toPDF(urls) {
	return new Promise(async (resolve, reject) => {
		try {
			if (!Array.isArray(urls)) urls = [urls]
			const doc = new PDFDocument({ margin: 0, size: 'A4' })
			const buffers = []
			
			for (let i = 0; i < urls.length; i++) {
				const response = await fetch(urls[i], { headers: { referer: urls[i] }})
				if (!response.ok) continue
				
				const type = response.headers.get('content-type')
				if (!/image/.test(type)) continue
				
				let buffer = Buffer.from(await response.arrayBuffer())
				if (/gif|webp/.test(type)) buffer = await sharp(buffer).png().toBuffer()
				
				doc.image(buffer, 0, 0, { fit: [595.28, 841.89], align: 'center', valign: 'center' })
				if (urls.length !== i + 1) doc.addPage()
			}
			
			doc.on('data', (chunk) => buffers.push(chunk))
			doc.on('end', () => resolve(Buffer.concat(buffers)))
			doc.on('error', reject)
			doc.end()
		} catch (e) {
			console.log(e)
			reject(e)
		}
	})
}

async function processImageUpscaler(images, denoise, format, type) {
    return new Promise(async (resolve, reject) => {
      try {
        const formData = new FormData();
        formData.append("denoise", denoise);
        formData.append("scale", "true");
        formData.append("format", format);
        formData.append("type", type);
        formData.append("file", images, {
          filename:
            "images_" + "downlaod.jpg",
          contentType: "image/jpeg",
        });

        // Convert FormData to Buffer
       // const bufferFormData = await formData.getBuffer();

        const response = await axios.request({
          method: "POST",
          url: "https://api.alcaamado.es/ns-api-waifu2x/v1/convert",
          data: formData,
          debug: true,
          headers: {
            Authority: "api.alcaamado.es",
            Accept: "application/json",
            Referer: "https://waifu2x.pro/",
            Origin: "https://waifu2x.pro",
            "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": `multipart/form-data; boundary=${formData._boundary}`,
          },
        });

        const images = await axios.request({
          method: "GET",
          url:
            "https://api.alcaamado.es/api/v2/waifu2x/get?hash=" +
            response.data.hash +
            "&type=" +
            format,
          headers: {
            Accept: "image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
            "Content-Type": "image/jpg",
            Referer: "https://waifu2x.pro/",
            "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",
          },
          responseType: "arraybuffer",
        });

        resolve(images.data)
      } catch (error) {
        reject(error);
      }
    });
}

async function processImage2Img(imgBuffer, prompt) {
  return new Promise(async (resolve, reject) => {
    try {
      const FormData = require('formdata-node');
      const Blob = require('formdata-node/Blob');
      const type = fileType(imgBuffer);
      const convertingBlob = new Blob([imgBuffer], { type: type.mime });

      const form = new FormData();
      form.append('image', convertingBlob, "image" + type.ext);
						
      const app = await Client.connect("Manjushri/SDXL-Turbo-Img2Img-CPU");
      const result = await app.predict("/predict", [
				  form, 	// blob in 'Raw Image.' Image component		
				  prompt, // string  in 'Prompt Input Text. 77 Token (Keyword or Symbol) Maximum' Textbox component		
				  1, // number (numeric value between 1 and 5) in 'Number of Iterations' Slider component		
				  987654321987654321, // number (numeric value between 0 and 987654321987654321) in 'Seed' Slider component		
				  0.1, // number (numeric value between 0.1 and 1) in 'Strength' Slider component
  ]);
      resolve(result.data);
    } catch(e) {
      reject(e.message);
    }
  });
}

async function processImageAnime(inputBuffer) {
    try {
       // const base64String = Buffer.from(inputBuffer, 'binary').toString('base64');
        const apiResponse = await axios.post('https://www.drawever.com/api/photo-to-anime', {
            data: `data:image/png;base64,${inputBuffer}`,
        }, {
            headers: {
                'Content-Type': 'application/json',
            },
        });

        const link = 'https://www.drawever.com' + (apiResponse.data.urls[1] || apiResponse.data.urls[0]);
        const {
            data: imageBuffer
        } = await axios.get(link, {
            responseType: 'arraybuffer'
        });

        const image = await Jimp.read(imageBuffer);
        const blackBackground = new Jimp(image.bitmap.width, 50, 0x000000FF);
        const font = await Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
        blackBackground.print(font, 10, 10, "SadTeams", blackBackground.bitmap.width - 20);
        image.composite(blackBackground, 0, image.bitmap.height - blackBackground.bitmap.height, {
            mode: Jimp.BLEND_SOURCE_OVER,
            opacityDest: 0.5,
            opacitySource: 1
        });

        const outputBuffer = await image.getBufferAsync(Jimp.MIME_JPEG);
        return outputBuffer;
    } catch (err) {
        console.error(err);
        throw err;
    }
}