jsdecryptor 4.0.3

package/davelib/sticker.js

@@ -0,0 +1,208 @@
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { spawn } = require('child_process')
+const { fileTypeFromBuffer } = require('file-type')
+const webp = require('node-webpmux')
+const fetch = require('node-fetch')
+const ffmpeg = require('fluent-ffmpeg')
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const execAsync = promisify(exec)
+const { writeExifImg } = require('./exif')
+
+const tmp = path.join(__dirname, '../tmp')
+
+/**
+ * Image to Sticker
+ * @param {Buffer} img Image Buffer
+ * @param {String} url Image URL
+ */
+function sticker2(img, url) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      if (url) {
+        let res = await fetch(url)
+        if (res.status !== 200) throw await res.text()
+        img = await res.buffer()
+      }
+      let inp = path.join(tmp, +new Date + '.jpeg')
+      await fs.promises.writeFile(inp, img)
+      let ff = spawn('ffmpeg', [
+        '-y',
+        '-i', inp,
+        '-vf', 'scale=512:512:flags=lanczos:force_original_aspect_ratio=decrease,format=rgba,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1',
+        '-f', 'png',
+        '-'
+      ])
+      ff.on('error', reject)
+      ff.on('close', async () => {
+        await fs.promises.unlink(inp)
+      })
+      let bufs = []
+      const [_spawnprocess, ..._spawnargs] = [...(module.exports.support.gm ? ['gm'] : module.exports.magick ? ['magick'] : []), 'convert', 'png:-', 'webp:-']
+      let im = spawn(_spawnprocess, _spawnargs)
+      im.on('error', e => conn.reply(m.chat, util.format(e), m))
+      im.stdout.on('data', chunk => bufs.push(chunk))
+      ff.stdout.pipe(im.stdin)
+      im.on('exit', () => {
+        resolve(Buffer.concat(bufs))
+      })
+    } catch (e) {
+      reject(e)
+    }
+  })
+}
+
+/**
+ * Image/Video to Sticker
+ * @param {Buffer} img Image/Video Buffer
+ * @param {String} url Image/Video URL
+ * @param {String} packname EXIF Packname
+ * @param {String} author EXIF Author
+ */
+async function sticker3(img, url, packname, author) {
+  url = url ? url : await uploadFile(img)
+  let res = await fetch('https://api.xteam.xyz/sticker/wm?' + new URLSearchParams(Object.entries({
+    url,
+    packname,
+    author
+  })))
+  return await res.buffer()
+}
+
+/**
+ * Image to Sticker
+ * @param {Buffer} img Image/Video Buffer
+ * @param {String} url Image/Video URL
+ */
+async function sticker4(img, url) {
+  if (url) {
+    let res = await fetch(url)
+    if (res.status !== 200) throw await res.text()
+    img = await res.buffer()
+  }
+  return await ffmpeg(img, [
+    '-vf', 'scale=512:512:flags=lanczos:force_original_aspect_ratio=decrease,format=rgba,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1'
+  ], 'jpeg', 'webp')
+}
+
+async function sticker5(img, url, packname, author, categories = [''], extra = {}) {
+  const { Sticker } = await import('wa-sticker-formatter')
+  const stickerMetadata = {
+    type: 'default',
+    pack: packname,
+    author,
+    categories,
+    ...extra
+  }
+  return (new Sticker(img ? img : url, stickerMetadata)).toBuffer()
+}
+
+/**
+ * Convert using fluent-ffmpeg
+ * @param {string} img 
+ * @param {string} url 
+ */
+function sticker6(img, url) {
+  return new Promise(async (resolve, reject) => {
+    if (url) {
+      let res = await fetch(url)
+      if (res.status !== 200) throw await res.text()
+      img = await res.buffer()
+    }
+    const type = await fileTypeFromBuffer(img) || {
+      mime: 'application/octet-stream',
+      ext: 'bin'
+    }
+    if (type.ext == 'bin') reject(img)
+    const tmp = path.join(__dirname, `../tmp/${+ new Date()}.${type.ext}`)
+    const out = path.join(tmp + '.webp')
+    await fs.promises.writeFile(tmp, img)
+    // https://github.com/MhankBarBar/termux-wabot/blob/main/index.js#L313#L368
+    let Fffmpeg = /video/i.test(type.mime) ? fluent_ffmpeg(tmp).inputFormat(type.ext) : fluent_ffmpeg(tmp).input(tmp)
+    Fffmpeg
+      .on('error', function (err) {
+        console.error(err)
+        fs.promises.unlink(tmp)
+        reject(img)
+      })
+      .on('end', async function () {
+        fs.promises.unlink(tmp)
+        resolve(await fs.promises.readFile(out))
+      })
+      .addOutputOptions([
+        `-vcodec`, `libwebp`, `-vf`,
+        `scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15, pad=320:320:-1:-1:color=white@0.0, split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse`
+      ])
+      .toFormat('webp')
+      .save(out)
+  })
+}
+/**
+ * Add WhatsApp JSON Exif Metadata
+ * Taken from https://github.com/pedroslopez/whatsapp-web.js/pull/527/files
+ * @param {Buffer} webpSticker 
+ * @param {String} packname 
+ * @param {String} author 
+ * @param {String} categories 
+ * @param {Object} extra 
+ * @returns 
+ */
+async function addExif(webpSticker, packname, author, categories = [''], extra = {}) {
+  const img = new webp.Image();
+  const stickerPackId = crypto.randomBytes(32).toString('hex');
+  const json = { 'sticker-pack-id': stickerPackId, 'sticker-pack-name': packname, 'sticker-pack-publisher': author, 'emojis': categories, ...extra };
+  let exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+  let jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8');
+  let exif = Buffer.concat([exifAttr, jsonBuffer]);
+  exif.writeUIntLE(jsonBuffer.length, 14, 4);
+  await img.load(webpSticker)
+  img.exif = exif
+  return await img.save(null)
+}
+
+/**
+ * Convert media to WebP and add metadata
+ * @param {Buffer} inputBuffer Image Buffer
+ * @param {String} url Image URL
+ * @param {String} packname EXIF Packname
+ * @param {String} author EXIF Author
+ */
+async function sticker(isImage, url, packname, author) {
+    try {
+        const response = await fetch(url);
+        const buffer = await response.buffer();
+        
+        // Create sticker with metadata
+        const stickerBuffer = await writeExifImg(buffer, {
+            packname: packname || 'WhatsApp Bot',
+            author: author || '@bot'
+        });
+        
+        return stickerBuffer;
+    } catch (error) {
+        console.error('Error in sticker creation:', error);
+        return null;
+    }
+}
+
+const support = {
+  ffmpeg: true,
+  ffprobe: true,
+  ffmpegWebp: true,
+  convert: true,
+  magick: false,
+  gm: false,
+  find: false
+}
+
+module.exports = {
+  sticker,
+  sticker2,
+  sticker3,
+  sticker4,
+  sticker6,
+  addExif,
+  support
+}

package/davelib/tempCleanup.js

@@ -0,0 +1,53 @@
+const fs = require('fs');
+const path = require('path');
+
+// Utility for cleaning temp files
+function cleanupTempFiles() {
+    const tempDir = path.join(process.cwd(), 'temp');
+    
+    if (!fs.existsSync(tempDir)) {
+        return;
+    }
+    
+    fs.readdir(tempDir, (err, files) => {
+        if (err) {
+            console.error('Error reading temp directory:', err);
+            return;
+        }
+        
+        let cleanedCount = 0;
+        const now = Date.now();
+        const maxAge = 3 * 60 * 60 * 1000; // 3 hours
+        
+        files.forEach(file => {
+            const filePath = path.join(tempDir, file);
+            
+            fs.stat(filePath, (err, stats) => {
+                if (err) return;
+                
+                // Delete files older than 3 hours
+                if (now - stats.mtimeMs > maxAge) {
+                    fs.unlink(filePath, (err) => {
+                        if (!err) {
+                            cleanedCount++;
+                            console.log(`🧹 Cleaned temp file: ${file}`);
+                        }
+                    });
+                }
+            });
+        });
+        
+        if (cleanedCount > 0) {
+            console.log(`🧹 Cleaned ${cleanedCount} temp files`);
+        }
+    });
+}
+
+// Cleanup on startup
+cleanupTempFiles();
+
+// Cleanup every hour
+setInterval(cleanupTempFiles, 60 * 60 * 1000);
+
+module.exports = { cleanupTempFiles };
+

package/davelib/tictactoe.js

@@ -0,0 +1,104 @@
+class TicTacToe {
+    constructor(playerX = 'X', playerO = 'O') {
+        this.playerX = playerX;
+        this.playerO = playerO;
+        this._isOTurn = false;
+        this._xMoves = 0;
+        this._oMoves = 0;
+        this.turns = 0;
+    }
+
+    get board() {
+        return this._xMoves | this._oMoves;
+    }
+
+    get currentTurn() {
+        return this._isOTurn ? this.playerO : this.playerX;
+    }
+
+    get winner() {
+        const winningPatterns = [
+            0b111000000, 0b000111000, 0b000000111,
+            0b100100100, 0b010010010, 0b001001001,
+            0b100010001, 0b001010100
+        ];
+        for (let pattern of winningPatterns) {
+            if ((this._xMoves & pattern) === pattern) return this.playerX;
+            if ((this._oMoves & pattern) === pattern) return this.playerO;
+        }
+        return null;
+    }
+
+    get isDraw() {
+        return this.turns === 9 && !this.winner;
+    }
+
+    turn(isO, pos) {
+        if (this.winner || this.isDraw) return false;
+        if (pos < 0 || pos > 8) return false;
+        if (this.board & (1 << pos)) return false;
+        if (isO !== this._isOTurn) return false;
+
+        const move = 1 << pos;
+        if (this._isOTurn) {
+            this._oMoves |= move;
+        } else {
+            this._xMoves |= move;
+        }
+        this._isOTurn = !this._isOTurn;
+        this.turns++;
+        return true;
+    }
+
+    getAvailableMoves() {
+        const moves = [];
+        for (let i = 0; i < 9; i++) {
+            if (!(this.board & (1 << i))) moves.push(i);
+        }
+        return moves;
+    }
+
+    render() {
+        return [...Array(9)].map((_, i) => {
+            const bit = 1 << i;
+            if (this._xMoves & bit) return 'X';
+            if (this._oMoves & bit) return 'O';
+            return String(i + 1);
+        });
+    }
+
+    findBestMove() {
+        const available = this.getAvailableMoves();
+        if (available.length === 0) return -1;
+
+        const winPatterns = [
+            [0,1,2],[3,4,5],[6,7,8],
+            [0,3,6],[1,4,7],[2,5,8],
+            [0,4,8],[2,4,6]
+        ];
+        const board = this.render();
+        const aiSymbol = this._isOTurn ? 'O' : 'X';
+        const humanSymbol = this._isOTurn ? 'X' : 'O';
+
+        for (const pattern of winPatterns) {
+            const cells = pattern.map(i => board[i]);
+            const aiCount = cells.filter(c => c === aiSymbol).length;
+            const emptyIdx = pattern.find(i => board[i] !== 'X' && board[i] !== 'O');
+            if (aiCount === 2 && emptyIdx !== undefined) return emptyIdx;
+        }
+
+        for (const pattern of winPatterns) {
+            const cells = pattern.map(i => board[i]);
+            const humanCount = cells.filter(c => c === humanSymbol).length;
+            const emptyIdx = pattern.find(i => board[i] !== 'X' && board[i] !== 'O');
+            if (humanCount === 2 && emptyIdx !== undefined) return emptyIdx;
+        }
+
+        if (available.includes(4)) return 4;
+        const corners = [0, 2, 6, 8].filter(c => available.includes(c));
+        if (corners.length > 0) return corners[Math.floor(Math.random() * corners.length)];
+        return available[Math.floor(Math.random() * available.length)];
+    }
+}
+
+module.exports = TicTacToe;

package/davelib/uploadImage.js

@@ -0,0 +1,100 @@
+const fetch = require('node-fetch');
+const FormData = require('form-data');
+const FileType = require('file-type');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Upload file to qu.ax
+ * Supported mimetypes:
+ * - `image/jpeg`
+ * - `image/jpg`
+ * - `image/png`
+ * @param {Buffer} buffer File Buffer
+ * @return {Promise<string>}
+ */
+async function uploadImage(buffer) {
+    try {
+        // Create temp directory if it doesn't exist
+        const tmpDir = path.join(process.cwd(), 'tmp');
+        if (!fs.existsSync(tmpDir)) {
+            fs.mkdirSync(tmpDir, { recursive: true });
+        }
+
+        // Get file type
+        const fileType = await FileType.fromBuffer(buffer);
+        const { ext, mime } = fileType || { ext: 'png', mime: 'image/png' };
+        const tempFile = path.join(tmpDir, `temp_${Date.now()}.${ext}`);
+
+        // Save buffer to temp file
+        fs.writeFileSync(tempFile, buffer);
+
+        // Create form data
+        const form = new FormData();
+        form.append('files[]', fs.createReadStream(tempFile));
+
+        // Upload to qu.ax
+        const response = await fetch('https://qu.ax/upload.php', {
+            method: 'POST',
+            body: form,
+            headers: form.getHeaders()
+        });
+
+        // Clean up temp file
+        fs.unlinkSync(tempFile);
+
+        const result = await response.json();
+        if (result && result.success) {
+            return result.files[0].url;
+        } else {
+            // Fallback to telegraph if qu.ax fails
+            const telegraphForm = new FormData();
+            telegraphForm.append('file', buffer, {
+                filename: `upload.${ext}`,
+                contentType: mime
+            });
+
+            const telegraphResponse = await fetch('https://telegra.ph/upload', {
+                method: 'POST',
+                body: telegraphForm
+            });
+
+            const img = await telegraphResponse.json();
+            if (img[0]?.src) {
+                return 'https://telegra.ph' + img[0].src;
+            }
+            
+            throw new Error('Failed to upload image to both services');
+        }
+    } catch (error) {
+        console.error('Upload error:', error);
+        throw error;
+    }
+}
+
+module.exports = { uploadImage };
+
+/**
+ * Alternative upload to telegra.ph (backup)
+ */
+/*
+async function uploadImageTelegraph(buffer) {
+    try {
+        const { ext, mime } = await fileTypeFromBuffer(buffer);
+        const form = new FormData();
+        const blob = new Blob([buffer.toArrayBuffer()], { type: mime });
+        form.append('file', blob, 'tmp.' + ext);
+
+        const response = await fetch('https://telegra.ph/upload', {
+            method: 'POST',
+            body: form
+        });
+
+        const img = await response.json();
+        if (img.error) throw img.error;
+        return 'https://telegra.ph' + img[0].src;
+    } catch (error) {
+        throw error;
+    }
+}
+*/ 

package/davelib/uploader.js

@@ -0,0 +1,110 @@
+/**
+ * Knight Bot - A WhatsApp Bot
+ * Copyright (c) 2024 Professor
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License.
+ * 
+ * Credits:
+ * - Baileys Library by @adiwajshing
+ * - Pair Code implementation inspired by TechGod143 & DGXEON
+ */
+let axios = require('axios')
+let BodyForm = require('form-data')
+let { fromBuffer } = require('file-type')
+let fetch = require('node-fetch')
+let fs = require('fs')
+let cheerio = require('cheerio')
+
+
+
+function TelegraPh (Path) {
+	return new Promise (async (resolve, reject) => {
+		if (!fs.existsSync(Path)) return reject(new Error("File not Found"))
+		try {
+			const form = new BodyForm();
+			form.append("file", fs.createReadStream(Path))
+			const data = await  axios({
+				url: "https://telegra.ph/upload",
+				method: "POST",
+				headers: {
+					...form.getHeaders()
+				},
+				data: form
+			})
+			return resolve("https://telegra.ph" + data.data[0].src)
+		} catch (err) {
+			return reject(new Error(String(err)))
+		}
+	})
+}
+
+async function UploadFileUgu (input) {
+	return new Promise (async (resolve, reject) => {
+			const form = new BodyForm();
+			form.append("files[]", fs.createReadStream(input))
+			await axios({
+				url: "https://uguu.se/upload.php",
+				method: "POST",
+				headers: {
+					"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36",
+					...form.getHeaders()
+				},
+				data: form
+			}).then((data) => {
+				resolve(data.data.files[0])
+			}).catch((err) => reject(err))
+	})
+}
+
+function webp2mp4File(path) {
+	return new Promise((resolve, reject) => {
+		 const form = new BodyForm()
+		 form.append('new-image-url', '')
+		 form.append('new-image', fs.createReadStream(path))
+		 axios({
+			  method: 'post',
+			  url: 'https://s6.ezgif.com/webp-to-mp4',
+			  data: form,
+			  headers: {
+				   'Content-Type': `multipart/form-data; boundary=${form._boundary}`
+			  }
+		 }).then(({ data }) => {
+			  const bodyFormThen = new BodyForm()
+			  const $ = cheerio.load(data)
+			  const file = $('input[name="file"]').attr('value')
+			  bodyFormThen.append('file', file)
+			  bodyFormThen.append('convert', "Convert WebP to MP4!")
+			  axios({
+				   method: 'post',
+				   url: 'https://ezgif.com/webp-to-mp4/' + file,
+				   data: bodyFormThen,
+				   headers: {
+						'Content-Type': `multipart/form-data; boundary=${bodyFormThen._boundary}`
+				   }
+			  }).then(({ data }) => {
+				   const $ = cheerio.load(data)
+				   const result = 'https:' + $('div#output > p.outfile > video > source').attr('src')
+				   resolve({
+						status: true,
+						message: "Created By MRHRTZ",
+						result: result
+				   })
+			  }).catch(reject)
+		 }).catch(reject)
+	})
+}
+
+async function floNime(medianya, options = {}) {
+const { ext } = await fromBuffer(medianya) || options.ext
+        var form = new BodyForm()
+        form.append('file', medianya, 'tmp.'+ext)
+        let jsonnya = await fetch('https://flonime.my.id/upload', {
+                method: 'POST',
+                body: form
+        })
+        .then((response) => response.json())
+        return jsonnya
+}
+
+module.exports = { TelegraPh, UploadFileUgu, webp2mp4File, floNime }

package/davelib/welcome.js

@@ -0,0 +1,100 @@
+const { addWelcome, delWelcome, isWelcomeOn, addGoodbye, delGoodBye, isGoodByeOn } = require('./index');
+const { createFakeContact, getBotName } = require('./fakeContact');
+
+async function handleWelcome(sock, chatId, message, match) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    
+    if (!match) {
+        return sock.sendMessage(chatId, {
+            text: `╭─❖ *WELCOME SETTINGS* ❖─╮\n` +
+                  `│ .welcome on - Enable\n` +
+                  `│ .welcome set <msg> - Customize\n` +
+                  `│ .welcome off - Disable\n` +
+                  `╰─────────────────╯\n\n` +
+                  `Variables: {user}, {group}, {description}, {bot}`,
+        }, { quoted: fake });
+    }
+
+    const [command, ...args] = match.split(' ');
+    const lowerCommand = command.toLowerCase();
+    const customMessage = args.join(' ');
+
+    if (lowerCommand === 'on') {
+        if (await isWelcomeOn(chatId)) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nWelcome messages are already active.` }, { quoted: fake });
+        }
+        await addWelcome(chatId, true, `@{user} Holla👋,\n\nWelcome to {group}.\n\nYou might want to read group description,\nFollow group rules to avoid being removed.\n\n {bot} 2026.`);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Welcome enabled. Use .welcome set to customize.` }, { quoted: fake });
+    }
+
+    if (lowerCommand === 'off') {
+        if (!(await isWelcomeOn(chatId))) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nWelcome messages are already off.` }, { quoted: fake });
+        }
+        await delWelcome(chatId);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Welcome disabled.` }, { quoted: fake });
+    }
+
+    if (lowerCommand === 'set') {
+        if (!customMessage) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nPlease provide a message.\nExample: .welcome set @{user} Holla👋, welcome!` }, { quoted: fake });
+        }
+        await addWelcome(chatId, true, customMessage);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Welcome message updated.\nPreview: ${customMessage}` }, { quoted: fake });
+    }
+
+    return sock.sendMessage(chatId, {
+        text: `*${botName}*\nInvalid. Use: on, off, or set <message>`,
+    }, { quoted: fake });
+}
+
+async function handleGoodbye(sock, chatId, message, match) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+    const lower = match?.toLowerCase();
+
+    if (!match) {
+        return sock.sendMessage(chatId, {
+            text: `╭─❖ *GOODBYE SETTINGS* ❖─╮\n` +
+                  `│ .goodbye on - Enable\n` +
+                  `│ .goodbye set <msg> - Customize\n` +
+                  `│ .goodbye off - Disable\n` +
+                  `╰───────────────────╯\n\n` +
+                  `Variables: {user}, {group}, {bot}`,
+        }, { quoted: fake });
+    }
+
+    if (lower === 'on') {
+        if (await isGoodByeOn(chatId)) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nGoodbye messages are already active.` }, { quoted: fake });
+        }
+        await addGoodbye(chatId, true, `@{user} Has run out of data, let's pray for the poor😢.\n\nAnyway Goodbye Hustler👋.`);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Goodbye enabled. Use .goodbye set to customize.` }, { quoted: fake });
+    }
+
+    if (lower === 'off') {
+        if (!(await isGoodByeOn(chatId))) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nGoodbye messages are already off.` }, { quoted: fake });
+        }
+        await delGoodBye(chatId);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Goodbye disabled.` }, { quoted: fake });
+    }
+
+    if (lower.startsWith('set ')) {
+        const customMessage = match.substring(4);
+        if (!customMessage) {
+            return sock.sendMessage(chatId, { text: `*${botName}*\nPlease provide a message.\nExample: .goodbye set @{user} Goodbye!` }, { quoted: fake });
+        }
+        await addGoodbye(chatId, true, customMessage);
+        return sock.sendMessage(chatId, { text: `*${botName}*\n✓ Goodbye message updated.\nPreview: ${customMessage}` }, { quoted: fake });
+    }
+
+    return sock.sendMessage(chatId, {
+        text: `*${botName}*\nInvalid. Use: on, off, or set <message>`,
+    }, { quoted: fake });
+}
+
+module.exports = { handleWelcome, handleGoodbye };