node-mac-recorder 2.23.3 → 2.24.1

package/binding.gyp

@@ -11,6 +11,7 @@
         "src/audio_recorder.mm",
         "src/audio_mixer.mm",
         "src/cursor_tracker.mm",
+        "src/keyboard_tracker.mm",
         "src/window_selector.mm"
       ],
       "include_dirs": [

package/index.js

@@ -65,6 +65,9 @@ class MacRecorder extends EventEmitter {
 		this.syncTimestamp = null;
 		this.audioCaptureFile = null;
 		this.audioCaptureActive = false;
+		// Keyboard (shortcut) capture variables
+		this.keyboardCaptureFile = null;
+		this.keyboardCaptureActive = false;
 
 		this.options = {
 			includeMicrophone: false, // Default olarak mikrofon kapalı
@@ -747,6 +750,7 @@ class MacRecorder extends EventEmitter {
 				this.outputPath = outputPath;
 
 				const cursorFilePath = path.join(outputDir, `temp_cursor_${sessionTimestamp}.json`);
+				const keyboardFilePath = path.join(outputDir, `temp_keyboard_${sessionTimestamp}.json`);
 				// CRITICAL FIX: Use .mov extension for camera (native recorder uses .mov, not .webm)
 				let cameraFilePath =
 					this.options.captureCamera === true
@@ -862,6 +866,31 @@ class MacRecorder extends EventEmitter {
 					this.recordingStartTime = syncTimestamp;
 					console.log(`🎯 CURSOR SYNC: Cursor tracking will use timestamp: ${syncTimestamp}`);
 
+					// CURSOR/VIDEO TIME ALIGNMENT:
+					// Cursor timeline'in t=0'i bu andir (syncTimestamp), ama videonun
+					// ILK KARESI daha once yakalanmis olabilir (ScreenCaptureKit
+					// baslatma gecikmesi + yukaridaki hazir-olma beklemesi). Editor
+					// "cursor'un ilk ornegi = video t=0" varsayarsa aradaki fark sabit
+					// bir zaman kaymasi olarak kalir. Native gercek video baslangicini
+					// biliyor; okuyup sakla ki stop'ta cursor JSON'una yazabilelim.
+					this.videoStartTimestamp = 0;
+					try {
+						const nativeVideoStart =
+							typeof nativeBinding.getVideoStartTimestamp === 'function'
+								? Number(nativeBinding.getVideoStartTimestamp())
+								: 0;
+						if (Number.isFinite(nativeVideoStart) && nativeVideoStart > 0) {
+							this.videoStartTimestamp = nativeVideoStart;
+							console.log(
+								`🎯 SYNC: Video first-frame timestamp: ${nativeVideoStart} (cursor starts ${(syncTimestamp - nativeVideoStart).toFixed(0)}ms later)`
+							);
+						} else {
+							console.warn('⚠️ SYNC: Video start timestamp unavailable — cursor sync metadata will be skipped');
+						}
+					} catch (videoStartError) {
+						console.warn('⚠️ SYNC: Video start timestamp read failed:', videoStartError.message);
+					}
+
 					const standardCursorOptions = {
 						videoRelative: true,
 						displayInfo: this.recordingDisplayInfo,
@@ -880,6 +909,16 @@ class MacRecorder extends EventEmitter {
 						console.warn('⚠️ Cursor tracking failed to start:', cursorError.message);
 						// Continue with recording even if cursor fails - don't stop native recording
 					}
+
+					// Klavye kısayolu yakalama (cursor ile AYNI zaman referansı)
+					try {
+						console.log('⌨️  SYNC: Starting keyboard shortcut capture at timestamp:', syncTimestamp);
+						await this.startKeyboardCapture(keyboardFilePath, { startTimestamp: syncTimestamp });
+						console.log('✅ SYNC: Keyboard shortcut capture started successfully');
+					} catch (keyboardError) {
+						console.warn('⚠️ Keyboard capture failed to start:', keyboardError.message);
+						// Klavye başlamazsa kayıt devam etsin
+					}
 				}
 
 				if (success) {
@@ -983,6 +1022,7 @@ class MacRecorder extends EventEmitter {
 							cameraOutputPath: this.cameraCaptureFile || null,
 							audioOutputPath: this.audioCaptureFile || null,
 							cursorOutputPath: cursorFilePath,
+								keyboardOutputPath: this.keyboardCaptureFile || keyboardFilePath,
 							sessionTimestamp: fileTimestampPayload,
 							syncTimestamp: startTimestampPayload,
 							fileTimestamp: fileTimestampPayload,
@@ -1003,6 +1043,7 @@ class MacRecorder extends EventEmitter {
 							cameraOutputPath: this.cameraCaptureFile || null,
 							audioOutputPath: this.audioCaptureFile || null,
 							cursorOutputPath: cursorFilePath,
+								keyboardOutputPath: this.keyboardCaptureFile || keyboardFilePath,
 							sessionTimestamp: fileTimestampPayload,
 							syncTimestamp: startTimestampPayload,
 							fileTimestamp: fileTimestampPayload,
@@ -1026,6 +1067,7 @@ class MacRecorder extends EventEmitter {
 						cameraOutputPath: this.cameraCaptureFile || null,
 						audioOutputPath: this.audioCaptureFile || null,
 						cursorOutputPath: cursorFilePath,
+								keyboardOutputPath: this.keyboardCaptureFile || keyboardFilePath,
 						sessionTimestamp: fileTimestampPayload,
 						syncTimestamp: startTimestampPayload,
 						fileTimestamp: fileTimestampPayload,
@@ -1107,6 +1149,17 @@ class MacRecorder extends EventEmitter {
 					}
 				}
 
+				// Klavye kısayolu yakalamayı durdur (instant)
+				if (this.keyboardCaptureActive) {
+					try {
+						console.log('🛑 SYNC: Stopping keyboard shortcut capture');
+						await this.stopKeyboardCapture();
+						console.log('✅ SYNC: Keyboard shortcut capture stopped');
+					} catch (keyboardError) {
+						console.warn('⚠️ Keyboard capture failed to stop:', keyboardError.message);
+					}
+				}
+
 				let success = false;
 
 				// 2. Stop native screen recording
@@ -1681,12 +1734,20 @@ class MacRecorder extends EventEmitter {
 				this.cursorCaptureInterval = null;
 
 				// Dosyayı kapat
+				let closedCursorFile = null;
 				if (this.cursorCaptureFile) {
 					const fs = require("fs");
 					fs.appendFileSync(this.cursorCaptureFile, "]");
+					closedCursorFile = this.cursorCaptureFile;
 					this.cursorCaptureFile = null;
 				}
 
+				// Cursor/video zaman hizalama bilgisini dosyaya yaz (editör bunu
+				// okuyup sabit kaymayı telafi ediyor).
+				if (closedCursorFile) {
+					this._writeCursorSyncMetadata(closedCursorFile);
+				}
+
 				// Değişkenleri temizle
 				this.lastCapturedData = null;
 				this.cursorCaptureStartTime = null;
@@ -1701,6 +1762,118 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Cursor JSON'una video/cursor zaman hizalama bilgisini yazar.
+	 *
+	 * NEDEN: Cursor timeline'inin t=0'i `syncTimestamp` (kayit hazir olduktan
+	 * sonraki an), videonun t=0'i ise ILK KARENIN yakalandigi an. ScreenCaptureKit
+	 * baslatma gecikmesi yuzunden bu ikisi ayni degil; fark bilinmezse oynatimda
+	 * sabit bir zaman kaymasi olusur (cursor video ile "sync tutmuyor").
+	 * Editor tarafi `_syncMetadata.videoStartTime` / `cursorStartTime` okuyup
+	 * tam telafi ediyor — burada sadece gercek degerleri yaziyoruz.
+	 *
+	 * Dosyanin ilk noktasina yazilir; okuyucu ilk metadata'yi bulup kullanir.
+	 */
+	_writeCursorSyncMetadata(cursorFilePath) {
+		const videoStartTime = Number(this.videoStartTimestamp);
+		const cursorStartTime = Number(this.syncTimestamp);
+		if (
+			!Number.isFinite(videoStartTime) ||
+			videoStartTime <= 0 ||
+			!Number.isFinite(cursorStartTime) ||
+			cursorStartTime <= 0
+		) {
+			// Native video baslangici okunamadiysa metadata yazma — editor eski
+			// (telafisiz) davranisa duser, yanlis bir offset uygulamaktan iyidir.
+			return;
+		}
+
+		try {
+			const fs = require("fs");
+			const raw = fs.readFileSync(cursorFilePath, "utf8");
+			const positions = JSON.parse(raw);
+			if (!Array.isArray(positions) || positions.length === 0) return;
+
+			positions[0]._syncMetadata = {
+				videoStartTime,
+				cursorStartTime,
+				startDelayMs: cursorStartTime - videoStartTime,
+				recordingType: this.options?.windowId
+					? "window"
+					: this.options?.captureArea
+						? "area"
+						: "display",
+			};
+
+			fs.writeFileSync(cursorFilePath, JSON.stringify(positions));
+			console.log(
+				`🎯 SYNC: Cursor sync metadata written (video→cursor delay ${(cursorStartTime - videoStartTime).toFixed(0)}ms)`
+			);
+		} catch (error) {
+			console.warn("⚠️ SYNC: Cursor sync metadata write failed:", error.message);
+		}
+	}
+
+	/**
+	 * Klavye kısayolu (shortcut) yakalamayı başlatır.
+	 * Native CGEventTap keyDown olaylarını dinler; yalnızca ⌘/⌃/⌥ modifier'lı
+	 * basımları zaman damgalı JSON olarak dosyaya yazar (gizlilik: düz yazım kaydedilmez).
+	 * @param {string} filepath - Keyboard data JSON dosya yolu
+	 * @param {Object} options
+	 * @param {number} options.startTimestamp - Cursor/video ile hizalamak için başlangıç zamanı (ms)
+	 */
+	async startKeyboardCapture(filepath, options = {}) {
+		if (typeof filepath !== "string" || !filepath) {
+			throw new Error("Keyboard capture filepath (string) required");
+		}
+		if (
+			!nativeBinding ||
+			typeof nativeBinding.startKeyboardTracking !== "function"
+		) {
+			// Eski native binary — sessizce atla
+			throw new Error("Native keyboard tracking not available in this build");
+		}
+		if (this.keyboardCaptureActive) {
+			throw new Error("Keyboard capture is already running");
+		}
+
+		const startTimestamp = Number(options.startTimestamp) || Date.now();
+		const started = nativeBinding.startKeyboardTracking(filepath, startTimestamp);
+		if (!started) {
+			throw new Error(
+				"Failed to start keyboard tracking (Accessibility permission may be required)"
+			);
+		}
+
+		this.keyboardCaptureFile = filepath;
+		this.keyboardCaptureActive = true;
+		this.emit("keyboardCaptureStarted", filepath);
+		return true;
+	}
+
+	/**
+	 * Klavye kısayolu yakalamayı durdurur ve JSON dosyasını kapatır.
+	 */
+	async stopKeyboardCapture() {
+		if (
+			!nativeBinding ||
+			typeof nativeBinding.stopKeyboardTracking !== "function"
+		) {
+			this.keyboardCaptureActive = false;
+			return false;
+		}
+		if (!this.keyboardCaptureActive) {
+			return false;
+		}
+		try {
+			nativeBinding.stopKeyboardTracking();
+		} finally {
+			this.keyboardCaptureActive = false;
+			this.emit("keyboardCaptureStopped");
+		}
+		return true;
+	}
+
 	/**
 	 * Anlık cursor pozisyonunu ve tipini döndürür
 	 * Display-relative koordinatlar döner (her zaman pozitif)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.23.3",
+	"version": "2.24.1",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/keyboard_tracker.mm

@@ -0,0 +1,291 @@
+// keyboard_tracker.mm
+// Kayıt sırasında kullanıcının klavye KISAYOLLARINI (shortcut) yakalar.
+// cursor_tracker.mm'deki CGEventTap altyapısıyla aynı desende çalışır: global bir
+// keyDown event tap kurar, her kısayol basımını zaman damgalı JSON olarak dosyaya
+// yazar. GİZLİLİK: yalnızca bir modifier (⌘ / ⌃ / ⌥) ile birlikte basılan tuşlar
+// yakalanır; düz metin yazımı (parola vb.) KAYDEDİLMEZ.
+
+#import <napi.h>
+#import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <Carbon/Carbon.h>
+#import "logging.h"
+
+// ---- Global durum (tek aktif oturum) --------------------------------------
+static CFMachPortRef g_kbEventTap = NULL;
+static CFRunLoopSourceRef g_kbRunLoopSource = NULL;
+static NSFileHandle *g_kbFileHandle = nil;
+static NSString *g_kbOutputPath = nil;
+static BOOL g_kbIsTracking = NO;
+static BOOL g_kbIsFirstWrite = YES;
+static double g_kbStartUnixMs = 0.0; // Senkron için referans başlangıç (ms)
+
+static double NowUnixMs() {
+    return [[NSDate date] timeIntervalSince1970] * 1000.0;
+}
+
+// Özel (yazılamayan) tuşların okunabilir isimleri. Diğer tuşlar için
+// charactersIgnoringModifiers kullanılır.
+static NSString *SpecialKeyName(unsigned short keyCode) {
+    switch (keyCode) {
+        case kVK_Return:        return @"Enter";
+        case kVK_ANSI_KeypadEnter: return @"Enter";
+        case kVK_Tab:           return @"Tab";
+        case kVK_Space:         return @"Space";
+        case kVK_Delete:        return @"Delete";      // Backspace
+        case kVK_ForwardDelete: return @"ForwardDelete";
+        case kVK_Escape:        return @"Esc";
+        case kVK_Home:          return @"Home";
+        case kVK_End:           return @"End";
+        case kVK_PageUp:        return @"PageUp";
+        case kVK_PageDown:      return @"PageDown";
+        case kVK_LeftArrow:     return @"Left";
+        case kVK_RightArrow:    return @"Right";
+        case kVK_DownArrow:     return @"Down";
+        case kVK_UpArrow:       return @"Up";
+        case kVK_F1:  return @"F1";
+        case kVK_F2:  return @"F2";
+        case kVK_F3:  return @"F3";
+        case kVK_F4:  return @"F4";
+        case kVK_F5:  return @"F5";
+        case kVK_F6:  return @"F6";
+        case kVK_F7:  return @"F7";
+        case kVK_F8:  return @"F8";
+        case kVK_F9:  return @"F9";
+        case kVK_F10: return @"F10";
+        case kVK_F11: return @"F11";
+        case kVK_F12: return @"F12";
+        default:      return nil;
+    }
+}
+
+static NSString *JsonEscape(NSString *input) {
+    if (!input) return @"";
+    NSMutableString *out = [NSMutableString stringWithCapacity:input.length + 2];
+    NSUInteger len = input.length;
+    for (NSUInteger i = 0; i < len; i++) {
+        unichar c = [input characterAtIndex:i];
+        switch (c) {
+            case '"':  [out appendString:@"\\\""]; break;
+            case '\\': [out appendString:@"\\\\"]; break;
+            case '\n': [out appendString:@"\\n"]; break;
+            case '\r': [out appendString:@"\\r"]; break;
+            case '\t': [out appendString:@"\\t"]; break;
+            default:
+                if (c < 0x20) {
+                    [out appendFormat:@"\\u%04x", c];
+                } else {
+                    [out appendFormat:@"%C", c];
+                }
+        }
+    }
+    return out;
+}
+
+static void WriteKeyboardEvent(NSString *jsonObject) {
+    if (!g_kbFileHandle || !jsonObject) return;
+    @try {
+        NSString *chunk = g_kbIsFirstWrite ? jsonObject : [@"," stringByAppendingString:jsonObject];
+        [g_kbFileHandle writeData:[chunk dataUsingEncoding:NSUTF8StringEncoding]];
+        g_kbIsFirstWrite = NO;
+    } @catch (NSException *e) {
+        // Sessizce devam et
+    }
+}
+
+// keyDown event callback — yalnızca modifier'lı basımları (kısayol) yazar.
+static CGEventRef KeyboardEventCallback(CGEventTapProxy proxy,
+                                        CGEventType type,
+                                        CGEventRef event,
+                                        void *refcon) {
+    if (type == kCGEventTapDisabledByTimeout || type == kCGEventTapDisabledByUserInput) {
+        if (g_kbEventTap) {
+            CGEventTapEnable(g_kbEventTap, true);
+        }
+        return event;
+    }
+
+    if (type != kCGEventKeyDown || !g_kbIsTracking) {
+        return event;
+    }
+
+    @autoreleasepool {
+        CGEventFlags flags = CGEventGetFlags(event);
+        BOOL hasCommand = (flags & kCGEventFlagMaskCommand) != 0;
+        BOOL hasControl = (flags & kCGEventFlagMaskControl) != 0;
+        BOOL hasOption  = (flags & kCGEventFlagMaskAlternate) != 0;
+        BOOL hasShift   = (flags & kCGEventFlagMaskShift) != 0;
+        BOOL hasFn      = (flags & kCGEventFlagMaskSecondaryFn) != 0;
+
+        // GİZLİLİK: Kısayol = ⌘ / ⌃ / ⌥ içermeli. Sadece Shift veya düz tuş → atla.
+        if (!(hasCommand || hasControl || hasOption)) {
+            return event;
+        }
+
+        unsigned short keyCode = (unsigned short)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
+
+        NSString *keyName = SpecialKeyName(keyCode);
+        NSString *chars = @"";
+        NSEvent *nsEvent = nil;
+        @try {
+            nsEvent = [NSEvent eventWithCGEvent:event];
+        } @catch (NSException *e) {
+            nsEvent = nil;
+        }
+        if (!keyName) {
+            NSString *raw = nsEvent ? [nsEvent charactersIgnoringModifiers] : nil;
+            if (raw.length > 0) {
+                chars = raw;
+                keyName = [raw uppercaseString];
+            } else {
+                keyName = [NSString stringWithFormat:@"Key%d", (int)keyCode];
+            }
+        } else {
+            chars = keyName;
+        }
+
+        double unixMs = NowUnixMs();
+        double relMs = g_kbStartUnixMs > 0 ? (unixMs - g_kbStartUnixMs) : 0.0;
+        if (relMs < 0) relMs = 0;
+
+        NSString *json = [NSString stringWithFormat:
+            @"{\"timestamp\":%.0f,\"unixTimeMs\":%.0f,\"type\":\"keydown\",\"keyCode\":%d,"
+            @"\"key\":\"%@\",\"chars\":\"%@\",\"modifiers\":{\"meta\":%@,\"control\":%@,"
+            @"\"alt\":%@,\"shift\":%@,\"fn\":%@}}",
+            relMs, unixMs, (int)keyCode,
+            JsonEscape(keyName), JsonEscape(chars),
+            hasCommand ? @"true" : @"false",
+            hasControl ? @"true" : @"false",
+            hasOption ? @"true" : @"false",
+            hasShift ? @"true" : @"false",
+            hasFn ? @"true" : @"false"];
+
+        WriteKeyboardEvent(json);
+    }
+
+    return event;
+}
+
+static void CleanupKeyboardTracking() {
+    g_kbIsTracking = NO;
+
+    if (g_kbFileHandle) {
+        @try {
+            // Açılış "[" başlangıçta yazıldığı için burada her zaman sadece "]" ile kapat.
+            // (boş durumda dosya "[]" olur, dolu durumda "[{...},{...}]")
+            [g_kbFileHandle writeData:[@"]" dataUsingEncoding:NSUTF8StringEncoding]];
+            [g_kbFileHandle synchronizeFile];
+            [g_kbFileHandle closeFile];
+        } @catch (NSException *e) {
+            // yut
+        }
+        g_kbFileHandle = nil;
+    }
+
+    if (g_kbEventTap) {
+        CGEventTapEnable(g_kbEventTap, false);
+        // CFRelease yapmıyoruz — cursor_tracker.mm ile aynı yaklaşım (sistem yönetsin)
+        g_kbEventTap = NULL;
+    }
+    if (g_kbRunLoopSource) {
+        g_kbRunLoopSource = NULL;
+    }
+
+    g_kbOutputPath = nil;
+    g_kbIsFirstWrite = YES;
+    g_kbStartUnixMs = 0.0;
+}
+
+// ---- NAPI: startKeyboardTracking(outputPath, startTimestampMs?) -----------
+Napi::Value StartKeyboardTracking(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (g_kbIsTracking) {
+        return Napi::Boolean::New(env, false);
+    }
+
+    std::string outputPath = info[0].As<Napi::String>().Utf8Value();
+    double startTs = 0.0;
+    if (info.Length() >= 2 && info[1].IsNumber()) {
+        startTs = info[1].As<Napi::Number>().DoubleValue();
+    }
+
+    @try {
+        g_kbOutputPath = [NSString stringWithUTF8String:outputPath.c_str()];
+
+        [[NSFileManager defaultManager] createFileAtPath:g_kbOutputPath contents:nil attributes:nil];
+        g_kbFileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_kbOutputPath] retain];
+        if (!g_kbFileHandle) {
+            return Napi::Boolean::New(env, false);
+        }
+        [g_kbFileHandle truncateFileAtOffset:0];
+        [g_kbFileHandle writeData:[@"[" dataUsingEncoding:NSUTF8StringEncoding]];
+
+        g_kbIsFirstWrite = YES;
+        g_kbStartUnixMs = startTs > 0 ? startTs : NowUnixMs();
+
+        CGEventMask eventMask = CGEventMaskBit(kCGEventKeyDown);
+        g_kbEventTap = CGEventTapCreate(kCGSessionEventTap,
+                                        kCGHeadInsertEventTap,
+                                        kCGEventTapOptionListenOnly,
+                                        eventMask,
+                                        KeyboardEventCallback,
+                                        NULL);
+
+        if (!g_kbEventTap) {
+            NSLog(@"⚠️  Failed to create keyboard event tap (requires Accessibility permission)");
+            CleanupKeyboardTracking();
+            return Napi::Boolean::New(env, false);
+        }
+
+        g_kbRunLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, g_kbEventTap, 0);
+        CFRunLoopAddSource(CFRunLoopGetMain(), g_kbRunLoopSource, kCFRunLoopCommonModes);
+        CGEventTapEnable(g_kbEventTap, true);
+
+        g_kbIsTracking = YES;
+        NSLog(@"✅ Keyboard shortcut tracking active");
+        return Napi::Boolean::New(env, true);
+    } @catch (NSException *exception) {
+        CleanupKeyboardTracking();
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// ---- NAPI: stopKeyboardTracking() -----------------------------------------
+Napi::Value StopKeyboardTracking(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (!g_kbIsTracking) {
+        return Napi::Boolean::New(env, false);
+    }
+    @try {
+        CleanupKeyboardTracking();
+        return Napi::Boolean::New(env, true);
+    } @catch (NSException *exception) {
+        CleanupKeyboardTracking();
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// ---- NAPI: getKeyboardTrackingStatus() ------------------------------------
+Napi::Value GetKeyboardTrackingStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Object status = Napi::Object::New(env);
+    status.Set("isTracking", Napi::Boolean::New(env, g_kbIsTracking));
+    status.Set("outputPath",
+               g_kbOutputPath ? Napi::String::New(env, [g_kbOutputPath UTF8String])
+                              : env.Null());
+    return status;
+}
+
+Napi::Object InitKeyboardTracker(Napi::Env env, Napi::Object exports) {
+    exports.Set("startKeyboardTracking", Napi::Function::New(env, StartKeyboardTracking));
+    exports.Set("stopKeyboardTracking", Napi::Function::New(env, StopKeyboardTracking));
+    exports.Set("getKeyboardTrackingStatus", Napi::Function::New(env, GetKeyboardTrackingStatus));
+    return exports;
+}

package/src/mac_recorder.mm

@@ -48,7 +48,10 @@ extern "C" {
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
 
-// Window selector function declarations  
+// Keyboard (shortcut) tracker function declarations
+Napi::Object InitKeyboardTracker(Napi::Env env, Napi::Object exports);
+
+// Window selector function declarations
 Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports);
 
 // Window selector overlay functions (external)
@@ -1717,7 +1720,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     
     // Initialize cursor tracker
     InitCursorTracker(env, exports);
-    
+
+    // Initialize keyboard (shortcut) tracker
+    InitKeyboardTracker(env, exports);
+
     // Initialize window selector
     InitWindowSelector(env, exports);