Create cartoony.js

plugins/cartoony.js

@@ -0,0 +1,247 @@
+const axios = require('axios');
+const FormData = require('form-data');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const cartoony = {
+  api: {
+    base: 'https://api.cartoony.app',
+    endpoint: {
+      generate: '/api/v1/generate/image',
+      styles: '/api/v1/styles?platform=android'
+    },
+    keyX: [
+      97,50,100,98,53,101,54,98,45,100,49,99,99,45,
+      52,50,54,102,45,56,51,51,99,45,50,48,50,53,
+      51,49,102,50,100,50,57,97
+    ],
+    get key() {
+      return String.fromCharCode(...this.keyX);
+    }
+  },
+
+  headers: {
+    'user-agent': 'NB Android/1.0.0',
+    'accept': 'application/json',
+    'accept-encoding': 'gzip',
+    'accept-charset': 'UTF-8'
+  },
+
+  now: () => Date.now(),
+  genUuid: () => crypto.randomUUID(),
+  genDeviceId: () => crypto.randomBytes(8).toString('hex'),
+  genRcUserId: () => `$RCAnonymousID:${crypto.randomBytes(16).toString('hex')}`,
+
+  getStyles: async () => {
+    try {
+      const res = await axios.get(
+        `${cartoony.api.base}${cartoony.api.endpoint.styles}`,
+        { headers: { ...cartoony.headers, 'x-api-key': cartoony.api.key } }
+      );
+      return res.data?.styles ?? [];
+    } catch {
+      return [];
+    }
+  },
+
+  retry: async (fn, retries = 3, delay = 1000) => {
+    let lastErr;
+    for (let i = 0; i < retries; i++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        if (i < retries - 1) await new Promise(r => setTimeout(r, delay));
+      }
+    }
+    throw lastErr;
+  }
+};
+
+async function downloadImage(url) {
+  const response = await axios.get(url, { 
+    responseType: 'arraybuffer',
+    timeout: 15000 
+  });
+  const tempPath = path.join('/tmp', `cartoony_${Date.now()}.jpg`);
+  fs.writeFileSync(tempPath, response.data);
+  return tempPath;
+}
+
+async function generateCartoony(imageUrl, styleId, quality = 'low') {
+  let tempPath = null;
+
+  try {
+    tempPath = await downloadImage(imageUrl);
+
+    const stats = fs.statSync(tempPath);
+    const maxSize = 5 * 1024 * 1024;
+    if (stats.size > maxSize) {
+      throw new Error('Image size exceeds 5MB limit');
+    }
+
+    const form = new FormData();
+    form.append('image', fs.createReadStream(tempPath), {
+      filename: 'user-image',
+      contentType: 'multipart/form-data'
+    });
+
+    form.append('style_id', styleId);
+    form.append('quality', quality);
+    form.append('generation_type', 'image_to_image');
+
+    const userId = cartoony.genUuid();
+    const rcUid = cartoony.genRcUserId();
+    const deviceId = cartoony.genDeviceId();
+    const timestamp = cartoony.now();
+
+    form.append('user_id', userId);
+    form.append('timestamp', timestamp);
+    form.append('platform', 'android');
+    form.append('app_version', '1.2.0');
+    form.append('locale', 'en-MM');
+    form.append('is_pro_user', 'true');
+    form.append('daily_count', '1');
+    form.append('rc_user_id', rcUid);
+    form.append('package_id', 'com.gigantic.cartoony');
+    form.append('device_id', deviceId);
+
+    const res = await cartoony.retry(
+      () =>
+        axios.post(
+          `${cartoony.api.base}${cartoony.api.endpoint.generate}`,
+          form,
+          {
+            headers: {
+              ...cartoony.headers,
+              ...form.getHeaders(),
+              'x-api-key': cartoony.api.key
+            },
+            maxBodyLength: Infinity,
+            timeout: 60000
+          }
+        ),
+      2
+    );
+
+    const data = res.data;
+    const base64Image = data?.generatedImage?.data ?? null;
+    const mimeType = data?.generatedImage?.mimeType ?? 'image/png';
+
+    if (!base64Image) {
+      throw new Error('Failed to generate image');
+    }
+
+    const imageBuffer = Buffer.from(base64Image, 'base64');
+    const ext = mimeType.split('/')[1] || 'png';
+    const randomName = crypto.randomBytes(16).toString('hex');
+    const fileName = `${randomName}.${ext}`;
+    
+    const tmpDir = path.join(__dirname, '../../tmp');
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    }
+    
+    const savePath = path.join(tmpDir, fileName);
+    fs.writeFileSync(savePath, imageBuffer);
+
+    return {
+      success: true,
+      fileName,
+      mimeType,
+      styleId,
+      quality
+    };
+
+  } finally {
+    if (tempPath && fs.existsSync(tempPath)) {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    }
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { image, model, quality, key } = req.query;
+
+    if (!image || !model || !key) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        message: 'Missing required parameters: image, model, and key'
+      });
+    }
+
+    const styles = await cartoony.getStyles();
+    const availableModels = styles.map(s => s.id);
+
+    const modelExists = availableModels.some(
+      m => m.toLowerCase() === model.toLowerCase()
+    );
+
+    if (!modelExists) {
+      return res.status(422).json({
+        author: 'Herza',
+        success: false,
+        message: 'Available Models only',
+        availableModels: styles.map(s => ({
+          id: s.id,
+          name: s.name,
+          isPro: s.isPro
+        }))
+      });
+    }
+
+    const validQualities = ['low', 'medium'];
+    const selectedQuality = quality?.toLowerCase() || 'low';
+    
+    if (!validQualities.includes(selectedQuality)) {
+      return res.status(422).json({
+        author: 'Herza',
+        success: false,
+        message: 'Invalid quality parameter. Available: low, medium',
+        availableQualities: validQualities
+      });
+    }
+
+    const result = await generateCartoony(image, model, selectedQuality);
+    
+    const protocol = req.protocol || 'http';
+    const host = req.get('host');
+    const fileUrl = `${protocol}://${host}/tmp/${result.fileName}`;
+
+    res.json({
+      author: 'Herza',
+      success: true,
+      data: {
+        url: fileUrl,
+        mimeType: result.mimeType,
+        model: result.styleId,
+        quality: result.quality
+      }
+    });
+
+  } catch (error) {
+    console.error('Cartoony API Error:', error);
+    res.status(500).json({
+      author: 'Herza',
+      success: false,
+      message: error.message || 'Internal server error'
+    });
+  }
+};
+
+module.exports = {
+  name: 'Cartoony AI Image Generator',
+  description: 'Convert images to various AI styles using Cartoony API',
+  type: 'GET',
+  routes: ['api/AI/cartoony'],
+  tags: ['ai', 'image', 'cartoony', 'converter', 'style-transfer'],
+  main: ['AI'],
+  parameters: ['image', 'model', 'quality', 'key'],
+  enabled: true,
+  handler
+};