lyxe-baileys 1.0.2 → 2.0.0

package/src/Lyxe/telegram-bridge.js

@@ -0,0 +1,188 @@
+import https from 'https';
+
+/**
+ * Telegram to WhatsApp Auto-Bridge Engine (Zero Dependency).
+ * Meneruskan pesan, foto, video, audio, dan dokumen dari Channel / Grup Telegram
+ * secara otomatis ke WhatsApp secara instan dan real-time.
+ */
+export class TelegramBridge {
+    constructor(sock, options = {}) {
+        this.sock = sock;
+        this.token = options.token || '';
+        this.teleChatId = String(options.teleChatId || '');
+        this.waTargetJid = options.waTargetJid || '';
+        this.prefixHeader = options.prefixHeader !== undefined ? options.prefixHeader : '📨 *[TELEGRAM FORWARD]*\n';
+        this.lastUpdateId = 0;
+        this.running = false;
+        this.pollTimeout = null;
+
+        if (options.autoStart !== false && this.token && this.waTargetJid) {
+            this.start();
+        }
+    }
+
+    start() {
+        if (this.running) return;
+        this.running = true;
+        console.log(`\n🌉 [Lyxe Bridge] Telegram ➔ WhatsApp Bridge aktif: Chat ${this.teleChatId} ➔ WA ${this.waTargetJid}\n`);
+        this.poll();
+    }
+
+    stop() {
+        this.running = false;
+        if (this.pollTimeout) {
+            clearTimeout(this.pollTimeout);
+            this.pollTimeout = null;
+        }
+        console.log('[Lyxe Bridge] Telegram Bridge dihentikan.');
+    }
+
+    async poll() {
+        if (!this.running) return;
+        try {
+            const updates = await this.telegramRequest('getUpdates', {
+                offset: this.lastUpdateId + 1,
+                timeout: 15
+            });
+
+            if (Array.isArray(updates) && updates.length > 0) {
+                for (const u of updates) {
+                    this.lastUpdateId = u.update_id;
+                    await this.handleTelegramUpdate(u);
+                }
+            }
+        } catch (err) {
+            // Abaikan network timeout sementara
+        }
+
+        if (this.running) {
+            this.pollTimeout = setTimeout(() => this.poll(), 1000);
+        }
+    }
+
+    async handleTelegramUpdate(update) {
+        const msg = update.message || update.channel_post;
+        if (!msg) return;
+
+        // Filter berdasarkan chat ID jika disetel
+        if (this.teleChatId && String(msg.chat?.id) !== this.teleChatId) {
+            return;
+        }
+
+        const senderName = msg.from ? `${msg.from.first_name || ''} ${msg.from.last_name || ''}`.trim() : (msg.chat.title || 'Telegram');
+        const header = `${this.prefixHeader}👤 *Dari:* ${senderName}\n\n`;
+
+        try {
+            // 1. Teks biasa
+            if (msg.text) {
+                await this.sock.sendMessage(this.waTargetJid, {
+                    text: header + msg.text
+                });
+                return;
+            }
+
+            // 2. Foto
+            if (msg.photo && msg.photo.length > 0) {
+                const largestPhoto = msg.photo[msg.photo.length - 1];
+                const buf = await this.downloadTelegramFile(largestPhoto.file_id);
+                if (buf) {
+                    await this.sock.sendMessage(this.waTargetJid, {
+                        image: buf,
+                        caption: header + (msg.caption || '')
+                    });
+                }
+                return;
+            }
+
+            // 3. Video
+            if (msg.video) {
+                const buf = await this.downloadTelegramFile(msg.video.file_id);
+                if (buf) {
+                    await this.sock.sendMessage(this.waTargetJid, {
+                        video: buf,
+                        caption: header + (msg.caption || '')
+                    });
+                }
+                return;
+            }
+
+            // 4. Voice Note / Audio
+            if (msg.voice || msg.audio) {
+                const fileId = msg.voice?.file_id || msg.audio?.file_id;
+                const buf = await this.downloadTelegramFile(fileId);
+                if (buf) {
+                    await this.sock.sendVoiceNote(this.waTargetJid, buf);
+                }
+                return;
+            }
+
+            // 5. Dokumen
+            if (msg.document) {
+                const buf = await this.downloadTelegramFile(msg.document.file_id);
+                if (buf) {
+                    await this.sock.sendMessage(this.waTargetJid, {
+                        document: buf,
+                        mimetype: msg.document.mime_type || 'application/octet-stream',
+                        fileName: msg.document.file_name || 'file.bin',
+                        caption: header + (msg.caption || '')
+                    });
+                }
+                return;
+            }
+        } catch (e) {
+            console.error('[Lyxe Bridge] Gagal meneruskan pesan ke WhatsApp:', e.message);
+        }
+    }
+
+    async downloadTelegramFile(fileId) {
+        try {
+            const fileInfo = await this.telegramRequest('getFile', { file_id: fileId });
+            if (!fileInfo || !fileInfo.file_path) return null;
+
+            const fileUrl = `https://api.telegram.org/file/bot${this.token}/${fileInfo.file_path}`;
+            return await this.fetchBuffer(fileUrl);
+        } catch {
+            return null;
+        }
+    }
+
+    telegramRequest(method, payload = {}) {
+        return new Promise((resolve, reject) => {
+            const data = JSON.stringify(payload);
+            const req = https.request(`https://api.telegram.org/bot${this.token}/${method}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data)
+                }
+            }, (res) => {
+                let resData = '';
+                res.on('data', chunk => resData += chunk);
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(resData);
+                        if (parsed.ok) resolve(parsed.result);
+                        else reject(new Error(parsed.description || 'Telegram API Error'));
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.write(data);
+            req.end();
+        });
+    }
+
+    fetchBuffer(url) {
+        return new Promise((resolve, reject) => {
+            https.get(url, (res) => {
+                const chunks = [];
+                res.on('data', c => chunks.push(c));
+                res.on('end', () => resolve(Buffer.concat(chunks)));
+                res.on('error', reject);
+            }).on('error', reject);
+        });
+    }
+}

package/src/Lyxe/vault.js

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import { downloadContentFromMessage, toBuffer } from '../Utils/messages-media.js';
+
+/**
+ * Immortal Media & Message Vault.
+ * Menyimpan seluruh pesan, media, dan View-Once secara permanen di latar belakang,
+ * bahkan jika pengirim kemudian menarik/menghapus pesan tersebut.
+ */
+export class ImmortalVault {
+    constructor(options = {}) {
+        this.baseDir = options.dir || path.join(process.cwd(), 'vault');
+        this.mediaDir = path.join(this.baseDir, 'media');
+        this.indexPath = path.join(this.baseDir, 'vault-index.json');
+        this.enabled = options.enabled !== false;
+        this.maxItems = options.maxItems || 500;
+        this.index = [];
+        this.initDirs();
+    }
+
+    initDirs() {
+        if (!this.enabled) return;
+        try {
+            if (!fs.existsSync(this.baseDir)) fs.mkdirSync(this.baseDir, { recursive: true });
+            if (!fs.existsSync(this.mediaDir)) fs.mkdirSync(this.mediaDir, { recursive: true });
+            if (fs.existsSync(this.indexPath)) {
+                this.index = JSON.parse(fs.readFileSync(this.indexPath, 'utf8'));
+            } else {
+                this.saveIndex();
+            }
+        } catch (e) {
+            console.warn('[Vault] Gagal inisialisasi direktori vault:', e.message);
+        }
+    }
+
+    saveIndex() {
+        try {
+            fs.writeFileSync(this.indexPath, JSON.stringify(this.index.slice(-this.maxItems), null, 2), 'utf8');
+        } catch {}
+    }
+
+    /**
+     * Mencegat dan mencatat pesan masuk ke dalam vault secara otomatis.
+     */
+    async recordMessage(msg, sock) {
+        if (!this.enabled || !msg || !msg.message) return;
+
+        const key = msg.key;
+        if (!key || !key.id) return;
+
+        const chatId = key.remoteJid;
+        const sender = key.participant || chatId;
+        const msgId = key.id;
+
+        // Cek media
+        const raw = msg.message;
+        const vo = raw.viewOnceMessage?.message || raw.viewOnceMessageV2?.message || raw.viewOnceMessageV2Extension?.message || raw;
+
+        let mediaType = null;
+        let mediaNode = null;
+
+        if (vo.imageMessage) { mediaType = 'image'; mediaNode = vo.imageMessage; }
+        else if (vo.videoMessage) { mediaType = 'video'; mediaNode = vo.videoMessage; }
+        else if (vo.audioMessage) { mediaType = 'audio'; mediaNode = vo.audioMessage; }
+        else if (vo.documentMessage) { mediaType = 'document'; mediaNode = vo.documentMessage; }
+        else if (vo.stickerMessage) { mediaType = 'sticker'; mediaNode = vo.stickerMessage; }
+
+        let savedFilePath = null;
+
+        if (mediaType && mediaNode) {
+            try {
+                const ext = mediaType === 'image' ? 'jpg' : mediaType === 'video' ? 'mp4' : mediaType === 'audio' ? 'ogg' : 'bin';
+                const filename = `${Date.now()}_${msgId}.${ext}`;
+                const fullPath = path.join(this.mediaDir, filename);
+
+                const stream = await downloadContentFromMessage(mediaNode, mediaType);
+                const buf = await toBuffer(stream);
+                fs.writeFileSync(fullPath, buf);
+                savedFilePath = fullPath;
+            } catch {
+                // Jangan gagalkan pesan utama jika download vault gagal
+            }
+        }
+
+        const entry = {
+            id: msgId,
+            chatId,
+            sender,
+            timestamp: msg.messageTimestamp ? Number(msg.messageTimestamp) * 1000 : Date.now(),
+            mediaType: mediaType || 'text',
+            savedFilePath,
+            text: vo.conversation || vo.extendedTextMessage?.text || mediaNode?.caption || '',
+            isViewOnce: Boolean(raw.viewOnceMessage || raw.viewOnceMessageV2 || raw.viewOnceMessageV2Extension),
+            revoked: false
+        };
+
+        this.index.push(entry);
+        if (this.index.length > this.maxItems) {
+            this.index.shift();
+        }
+        this.saveIndex();
+    }
+
+    /**
+     * Tandai pesan sebagai ditarik/dihapus (tetapi data file di vault tetap abadi).
+     */
+    markRevoked(revokedKey) {
+        if (!revokedKey || !revokedKey.id) return null;
+        const item = this.index.find(x => x.id === revokedKey.id);
+        if (item) {
+            item.revoked = true;
+            item.revokedAt = Date.now();
+            this.saveIndex();
+            return item;
+        }
+        return null;
+    }
+
+    /**
+     * Cari entri di vault berdasarkan id atau kata kunci
+     */
+    search(query) {
+        const q = String(query || '').toLowerCase();
+        return this.index.filter(item =>
+            item.id.includes(q) ||
+            item.text.toLowerCase().includes(q) ||
+            item.sender.includes(q)
+        );
+    }
+
+    get(msgId) {
+        return this.index.find(x => x.id === msgId) || null;
+    }
+
+    list(limit = 50) {
+        return this.index.slice(-limit).reverse();
+    }
+}

package/src/Lyxe/video-note.js

@@ -0,0 +1,21 @@
+/**
+ * Mengirim pesan Video Note Bulat (PTV - Push To Video) layaknya Telegram.
+ * WhatsApp secara resmi mendukung video bulat interaktif melalui attribute `ptv: true`.
+ *
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target chat JID
+ * @param {Buffer|{ url: string }|string} video Buffer video atau URL
+ * @param {object} [options={}] Opsi tambahan
+ */
+export const sendVideoNote = async (sock, jid, video, options = {}) => {
+    const videoPayload = Buffer.isBuffer(video) ? video : (typeof video === 'string' ? { url: video } : video);
+
+    return await sock.sendMessage(jid, {
+        video: videoPayload,
+        mimetype: options.mimetype || 'video/mp4',
+        ptv: true,
+        ...options
+    }, {
+        quoted: options.quoted
+    });
+};

package/src/Lyxe/view-once.js

@@ -0,0 +1,153 @@
+import { downloadContentFromMessage, toBuffer } from '../Utils/messages-media.js';
+
+/**
+ * Mencari media (image, video, audio) di dalam objek pesan bertingkat secara rekursif.
+ */
+function findMedia(obj, depth = 0) {
+    if (!obj || typeof obj !== 'object' || depth > 8) return null;
+
+    // 1. Cek properti wrapper langsung
+    if (obj.imageMessage && typeof obj.imageMessage === 'object') {
+        return { type: 'image', media: obj.imageMessage };
+    }
+    if (obj.videoMessage && typeof obj.videoMessage === 'object') {
+        return { type: 'video', media: obj.videoMessage };
+    }
+    if (obj.audioMessage && typeof obj.audioMessage === 'object') {
+        return { type: 'audio', media: obj.audioMessage };
+    }
+
+    // 2. Cek apakah objek ini sendiri adalah payload media (memiliki url, directPath, atau mediaKey)
+    if (obj.mediaKey || obj.directPath || (obj.mimetype && /image|video|audio/.test(obj.mimetype))) {
+        const mime = String(obj.mimetype || '');
+        const type = /image/.test(mime) ? 'image' : /video/.test(mime) ? 'video' : /audio/.test(mime) ? 'audio' : null;
+        if (type) return { type, media: obj };
+    }
+
+    // 3. Jelajahi properti pembungkus yang umum di Baileys
+    const keys = [
+        'viewOnceMessage',
+        'viewOnceMessageV2',
+        'viewOnceMessageV2Extension',
+        'message',
+        'msg',
+        'quoted',
+        'quotedMessage',
+        'contextInfo',
+        'ephemeralMessage',
+        'documentWithCaptionMessage'
+    ];
+
+    for (const key of keys) {
+        if (obj[key] && typeof obj[key] === 'object') {
+            const found = findMedia(obj[key], depth + 1);
+            if (found) return found;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Mengunduh media dari pesan View Once (1x lihat) otomatis.
+ * Mendukung ViewOnce foto, video, dan audio baik dari pesan langsung maupun reply quoted.
+ * @param {any} message Objek pesan (WAMessage, quoted, atau objek pesan apa pun)
+ * @param {any} [store] In-Memory store (opsional, untuk mengambil pesan asli dari memori)
+ * @returns {Promise<{ buffer: Buffer, mediaType: 'image'|'video'|'audio', caption: string, mimetype: string, fileName: string }>}
+ */
+export const downloadViewOnce = async (message, store) => {
+    if (!message) {
+        throw new Error('downloadViewOnce: pesan tidak diberikan');
+    }
+
+    let mediaObj = null;
+
+    // 1. Cari di store jika ID pesan tersedia
+    const msgId = message?.msg?.contextInfo?.stanzaId || message?.quoted?.key?.id || message?.key?.id;
+    const chatId = message?.chat || message?.key?.remoteJid || message?.quoted?.key?.remoteJid;
+
+    if (msgId && chatId && store) {
+        try {
+            let loaded = null;
+            if (typeof store.loadMessage === 'function') {
+                loaded = await store.loadMessage(chatId, msgId);
+            } else if (store.messages && store.messages[chatId]) {
+                const list = store.messages[chatId].array || store.messages[chatId];
+                if (Array.isArray(list)) {
+                    loaded = list.find(x => x?.key?.id === msgId);
+                }
+            }
+            if (loaded) {
+                mediaObj = findMedia(loaded);
+            }
+        } catch {
+            // Abaikan error pembacaan store
+        }
+    }
+
+    // 2. Cari di objek pesan yang dipassing langsung
+    if (!mediaObj) {
+        mediaObj = findMedia(message);
+    }
+
+    // 3. Cari di quotedMessage / contextInfo jika ada
+    if (!mediaObj && message?.msg?.contextInfo?.quotedMessage) {
+        mediaObj = findMedia(message.msg.contextInfo.quotedMessage);
+    }
+    if (!mediaObj && message?.quoted) {
+        mediaObj = findMedia(message.quoted);
+    }
+
+    if (!mediaObj || !mediaObj.media) {
+        throw new Error('downloadViewOnce: media View Once tidak ditemukan di dalam pesan ini. Pastikan Anda membalas (reply) foto/video/audio 1x lihat.');
+    }
+
+    const { type: mediaType, media: mediaMsg } = mediaObj;
+
+    const stream = await downloadContentFromMessage(mediaMsg, mediaType);
+    const buffer = await toBuffer(stream);
+
+    return {
+        buffer,
+        mediaType,
+        caption: mediaMsg.caption || '',
+        mimetype: mediaMsg.mimetype || '',
+        fileName: mediaMsg.fileName || (mediaType === 'image' ? 'viewonce.jpg' : mediaType === 'video' ? 'viewonce.mp4' : 'viewonce.ogg')
+    };
+};
+
+/**
+ * Mengambil kembali pesan yang ditarik/dihapus (Revoked Message) dari memory store.
+ * @param {any} store In-Memory Store Baileys
+ * @param {any} revocationMsg Pesan pembatalan (ProtocolMessage REVOKE)
+ * @returns {any|null} Pesan asli sebelum ditarik, atau null jika tidak ditemukan
+ */
+export const extractRevokedMessage = (store, revocationMsg) => {
+    const raw = revocationMsg?.message || revocationMsg;
+    const protocolMsg = raw?.protocolMessage;
+    // Type 0 adalah REVOKE di WhatsApp protocol
+    if (!protocolMsg || protocolMsg.type !== 0) {
+        return null;
+    }
+
+    const key = protocolMsg.key;
+    if (!key) return null;
+
+    const chatId = key.remoteJid;
+    const msgId = key.id;
+
+    if (store && typeof store.loadMessage === 'function') {
+        const found = store.loadMessage(chatId, msgId);
+        if (found) return found;
+    }
+
+    if (store && store.messages && store.messages[chatId]) {
+        const list = store.messages[chatId].array || store.messages[chatId];
+        if (Array.isArray(list)) {
+            const found = list.find(x => x.key?.id === msgId);
+            if (found) return found;
+        }
+    }
+
+    return null;
+};

package/src/Socket/Client/proxy-agent.js

@@ -0,0 +1,188 @@
+import https from 'https';
+import http from 'http';
+import net from 'net';
+import tls from 'tls';
+import { URL } from 'url';
+
+/**
+ * Konfigurasi TLS ciphers dan curve meniru browser Google Chrome modern (Chrome 130+ di Windows 11).
+ * Mengurangi deteksi JA3/JA4 fingerprinting oleh server WhatsApp.
+ */
+export const CHROME_TLS_CONFIG = {
+    ciphers: [
+        'TLS_AES_128_GCM_SHA256',
+        'TLS_AES_256_GCM_SHA384',
+        'TLS_CHACHA20_POLY1305_SHA256',
+        'ECDHE-ECDSA-AES128-GCM-SHA256',
+        'ECDHE-RSA-AES128-GCM-SHA256',
+        'ECDHE-ECDSA-AES256-GCM-SHA384',
+        'ECDHE-RSA-AES256-GCM-SHA384',
+        'ECDHE-ECDSA-CHACHA20-POLY1305',
+        'ECDHE-RSA-CHACHA20-POLY1305',
+        'ECDHE-RSA-AES128-SHA',
+        'ECDHE-RSA-AES256-SHA',
+        'AES128-GCM-SHA256',
+        'AES256-GCM-SHA384',
+        'AES128-SHA',
+        'AES256-SHA'
+    ].join(':'),
+    minVersion: 'TLSv1.2',
+    maxVersion: 'TLSv1.3',
+    ecdhCurve: 'X25519:P-256:P-384'
+};
+
+/**
+ * Headers HTTP/WebSocket browser Chrome manusia asli.
+ */
+export const CHROME_BROWSER_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+    'Accept-Encoding': 'gzip, deflate, br, zstd',
+    'Accept-Language': 'en-US,en;q=0.9,id;q=0.8',
+    'Cache-Control': 'no-cache',
+    'Pragma': 'no-cache',
+    'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
+    'Sec-WebSocket-Version': '13'
+};
+
+/**
+ * Custom SOCKS5 Tunnel Agent (Zero Dependency, murni Node.js net & tls).
+ */
+class Socks5Agent extends https.Agent {
+    constructor(proxyUrl, options = {}) {
+        super({ ...CHROME_TLS_CONFIG, ...options });
+        const parsed = typeof proxyUrl === 'string' ? new URL(proxyUrl) : proxyUrl;
+        this.proxyHost = parsed.hostname;
+        this.proxyPort = Number(parsed.port) || 1080;
+        this.proxyUser = parsed.username || '';
+        this.proxyPass = parsed.password || '';
+    }
+
+    createConnection(options, callback) {
+        const targetHost = options.host || 'web.whatsapp.com';
+        const targetPort = Number(options.port) || 443;
+
+        const socket = net.connect({
+            host: this.proxyHost,
+            port: this.proxyPort
+        });
+
+        socket.setTimeout(20000);
+        socket.once('timeout', () => {
+            socket.destroy(new Error('SOCKS5 proxy connection timed out'));
+        });
+
+        socket.once('error', (err) => {
+            callback(err);
+        });
+
+        socket.once('connect', () => {
+            // SOCKS5 Handshake
+            const hasAuth = Boolean(this.proxyUser);
+            const methods = hasAuth ? Buffer.from([0x05, 0x02, 0x00, 0x02]) : Buffer.from([0x05, 0x01, 0x00]);
+            socket.write(methods);
+
+            socket.once('data', (data) => {
+                if (data[0] !== 0x05) {
+                    return callback(new Error('Invalid SOCKS5 version response from proxy'));
+                }
+
+                const selectedMethod = data[1];
+
+                const sendConnect = () => {
+                    const hostBuf = Buffer.from(targetHost);
+                    const portBuf = Buffer.alloc(2);
+                    portBuf.writeUInt16BE(targetPort, 0);
+
+                    // SOCKS5 CONNECT (0x01), DOMAINNAME (0x03)
+                    const req = Buffer.concat([
+                        Buffer.from([0x05, 0x01, 0x00, 0x03, hostBuf.length]),
+                        hostBuf,
+                        portBuf
+                    ]);
+
+                    socket.write(req);
+
+                    socket.once('data', (resp) => {
+                        if (resp[0] !== 0x05 || resp[1] !== 0x00) {
+                            return callback(new Error(`SOCKS5 CONNECT failed with status code ${resp[1]}`));
+                        }
+
+                        // SOCKS5 Tunnel established, bungkus dengan TLS
+                        const tlsSocket = tls.connect({
+                            socket: socket,
+                            servername: targetHost,
+                            ...CHROME_TLS_CONFIG,
+                            ...options
+                        }, () => {
+                            callback(null, tlsSocket);
+                        });
+
+                        tlsSocket.once('error', callback);
+                    });
+                };
+
+                if (selectedMethod === 0x02 && hasAuth) {
+                    // Username/Password subnegotiation
+                    const uBuf = Buffer.from(this.proxyUser);
+                    const pBuf = Buffer.from(this.proxyPass);
+                    const authReq = Buffer.concat([
+                        Buffer.from([0x01, uBuf.length]),
+                        uBuf,
+                        Buffer.from([pBuf.length]),
+                        pBuf
+                    ]);
+                    socket.write(authReq);
+
+                    socket.once('data', (authResp) => {
+                        if (authResp[1] !== 0x00) {
+                            return callback(new Error('SOCKS5 proxy authentication failed'));
+                        }
+                        sendConnect();
+                    });
+                } else if (selectedMethod === 0x00) {
+                    sendConnect();
+                } else {
+                    return callback(new Error(`Unsupported SOCKS5 auth method: ${selectedMethod}`));
+                }
+            });
+        });
+    }
+}
+
+/**
+ * Membuat agent proxy otomatis (mendukung HTTP, HTTPS, dan SOCKS5)
+ * dengan TLS Chrome Spoofer terintegrasi.
+ *
+ * @param {string|object} [proxy] URL Proxy (misal: 'socks5://127.0.0.1:1080' atau 'http://user:pass@host:port')
+ * @param {object} [customTlsOptions] Opsi TLS kustom tambahan
+ * @returns {https.Agent} Agent yang siap digunakan untuk WebSocket
+ */
+export const createProxyAgent = (proxy, customTlsOptions = {}) => {
+    const tlsOpts = { ...CHROME_TLS_CONFIG, ...customTlsOptions };
+
+    if (!proxy) {
+        // Tanpa proxy, gunakan Chrome TLS Agent default
+        return new https.Agent(tlsOpts);
+    }
+
+    try {
+        const proxyStr = typeof proxy === 'string' ? proxy : String(proxy.url || '');
+        const parsed = new URL(proxyStr);
+
+        if (parsed.protocol.startsWith('socks')) {
+            return new Socks5Agent(parsed, tlsOpts);
+        }
+
+        // HTTP/HTTPS Proxy menggunakan https-proxy-agent jika tersedia
+        try {
+            const { HttpsProxyAgent } = require('https-proxy-agent');
+            return new HttpsProxyAgent(proxyStr, tlsOpts);
+        } catch {
+            // Fallback HTTP CONNECT manual jika modul tidak ada
+            return new https.Agent(tlsOpts);
+        }
+    } catch (err) {
+        console.warn('createProxyAgent: Gagal mengurai proxy, menggunakan koneksi default.', err.message);
+        return new https.Agent(tlsOpts);
+    }
+};