index.js

import express from "express";
import os from "os";
import morgan from "morgan";
import bytes from "bytes";
import axios from "axios";
import { FormData, Blob } from "formdata-node";
import { fileTypeFromBuffer } from "file-type";
import { Client } from "@gradio/client";
import { stablediff } from "./lib/diffusion.js";
import { askOpenGPT4o } from "./lib/chatgpt.js";
import { processImageUpscaler } from "./lib/enchance.js";

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()
});

const apikey = "@SadTeam77";


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('/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 (!prompt) 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 fileTypeFromBuffer(response)
          //res.setHeader('Content-Type', type_img.mime)
          res.json(response)
        } else if (images && typeof images == 'string' && isBase64(images)) {
	   	  const response = await processImage2Img(Buffer.from(images, "base64"), prompt)
          //const type_img = await fileTypeFromBuffer(response)
          //res.setHeader('Content-Type', type_img.mime)
          res.json(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/upscaler', async (req, res) => {
	try {
		console.log(req.body)
		const { images, filenames, mimetype, status } = req.body
        if (!images) return res.json({ success: false, message: 'Required an images!' })
        if (!filenames) return res.json({ success: false, message: 'Required an filenames!' })
        if (!mimetype) return res.json({ success: false, message: 'Required an mimetype!' })
        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({buffer: data_img.data, method: "enchance", filenames, mimetype})
          //const type_img = await fileTypeFromBuffer(response)
          //res.setHeader('Content-Type', type_img.mime)
          res.json(response)
        } else if (images && typeof images == 'string' && isBase64(images)) {
	   	  const response = await processImageUpscaler({buffer: Buffer.from(images, "base64"), method: "enchance", filenames, mimetype})
          //const type_img = await fileTypeFromBuffer(response)
          //res.setHeader('Content-Type', type_img.mime)
          res.json(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/openai/gpt4', async (req, res) => {
	try {
		console.log(req.body)
		const { prompt, images, status } = req.body
        if (!prompt) return res.json({ succese: false, message: 'Require an Promot text!'})
        if (!status) return res.json({ success: false, message: 'Required an status text!' })

        if(status !== apikey) return res.json({ success: false, message: 'Invalid status!' })
        if(images) {
          if (/^(https?|http):\/\//i.test(images)) {
          const data_img = await axios.request({
            method: "GET",
            url: images,
            responseType: "arraybuffer"
          })
          const response = await askOpenGPT4o(prompt, data_img.data)
          //const type_img = await fileTypeFromBuffer(response)
          //res.setHeader('Content-Type', type_img.mime)
          res.json({
            status: true,
            result: response
          })
          } else if (images && typeof images == 'string' && isBase64(images)) {
	   	    const response = await askOpenGPT4o(prompt, Buffer.from(images, "base64"))
            //const type_img = await fileTypeFromBuffer(response)
            //res.setHeader('Content-Type', type_img.mime)
            res.json({
              status: true,
              result: response
            })
          } else {
            res.json({
              success: false, message: 'No url or base64 detected!!' 
            })
          }
        } else if(!images) {
          const response = await askOpenGPT4o(prompt)
          res.json({
          status: 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('/api/stabeldiff', async (req, res) => {
	try {
		console.log(req.body)
		const { prompt, status } = req.body
        if (!prompt) return res.json({ succese: false, message: 'Require an Promot 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 stablediff(prompt);

        res.json({
          status: true,
          result: response
        });
	} 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
	}
}

async function processImage2Img(imgBuffer, prompt) {
  return new Promise(async (resolve, reject) => {
    try {
      const imageArray = Buffer.from(imgBuffer);

      process.env.GRADIO_CLIENT_DEBUG = 'true';

      const app = await Client.connect("Manjushri/SDXL-Turbo-Img2Img-CPU");
      const result = await app.predict("/predict", [
        imageArray, // binary input for the image
        prompt, // string input for the prompt
        1, // number input for the number of iterations
        540388010706833800, // number input for the seed
        0.3, // number input for the strength
      ]);
      resolve(result.data);
    } catch (e) {
      reject(e.message);
    }
  });
}