Add launch global shortcuts to tray and More menu

electron/electron-env.d.ts

@@ -72,6 +72,7 @@ type RendererMarketplaceReviewStatus =
 type RendererMarketplaceSearchResult =
 	import("./extensions/extensionTypes").MarketplaceSearchResult;
 type RendererRecordingSessionData = import("./ipc/types").RecordingSessionData;
+type RendererLaunchShortcutAction = import("./ipc/shortcutTypes").LaunchShortcutAction;
 
 interface RendererFfmpegAudioMuxMetrics {
 	tempVideoWriteMs?: number;
@@ -558,7 +559,7 @@ interface Window {
 			startDelayMsByPath?: Record<string, number>;
 			error?: string;
 		}>;
-		setRecordingState: (recording: boolean) => Promise<void>;
+		setRecordingState: (recording: boolean, paused?: boolean) => Promise<void>;
 		getCursorTelemetry: (videoPath?: string) => Promise<{
 			success: boolean;
 			samples: CursorTelemetryPoint[];
@@ -579,10 +580,13 @@ interface Window {
 			cursors: Record<string, SystemCursorAsset>;
 			error?: string;
 		}>;
-		onStopRecordingFromTray: (callback: () => void) => () => void;
-		onRecordingStateChanged: (
-			callback: (state: { recording: boolean; sourceName: string }) => void,
-		) => () => void;
+	onStopRecordingFromTray: (callback: () => void) => () => void;
+	onTrayRecordingCommand: (
+		callback: (command: "start" | "pause" | "resume" | "stop") => void,
+	) => () => void;
+	onRecordingStateChanged: (
+		callback: (state: { recording: boolean; paused: boolean; sourceName: string }) => void,
+	) => () => void;
 		onRecordingSessionChanged: (
 			callback: (session: RendererRecordingSessionData | null) => void,
 		) => () => void;
@@ -829,6 +833,19 @@ interface Window {
 		}>;
 		getShortcuts: () => Promise<Record<string, unknown> | null>;
 		saveShortcuts: (shortcuts: unknown) => Promise<{ success: boolean; error?: string }>;
+		registerLaunchGlobalShortcuts: (config: unknown) => Promise<{
+			success: boolean;
+			unsupported?: boolean;
+			failedRegistrations?: Array<{
+				action: RendererLaunchShortcutAction;
+				accelerator: string;
+			}>;
+			error?: string;
+		}>;
+		unregisterLaunchGlobalShortcuts: () => Promise<{ success: boolean; error?: string }>;
+		onLaunchShortcutTriggered: (
+			callback: (action: RendererLaunchShortcutAction) => void,
+		) => () => void;
 		getAppSetting: (key: string) => unknown;
 		setAppSetting: (key: string, value: unknown) => boolean;
 		setHasUnsavedChanges: (hasChanges: boolean) => void;

electron/ipc/handlers.ts

@@ -55,7 +55,7 @@ export function registerIpcHandlers(
 	createSourceSelectorWindow: () => BrowserWindow,
 	_getMainWindow: () => BrowserWindow | null,
 	getSourceSelectorWindow: () => BrowserWindow | null,
-	onRecordingStateChange?: (recording: boolean, sourceName: string) => void,
+	onRecordingStateChange?: (recording: boolean, paused: boolean, sourceName: string) => void,
 ) {
 	registerSourceHandlers({
 		createEditorWindow,

electron/ipc/recording/mac.ts

@@ -168,6 +168,7 @@ export function attachNativeCaptureLifecycle(process: ChildProcessWithoutNullStr
 			if (!window.isDestroyed()) {
 				window.webContents.send("recording-state-changed", {
 					recording: false,
+					paused: false,
 					sourceName,
 				});
 			}

electron/ipc/recording/windows.ts

@@ -187,6 +187,7 @@ export function attachWindowsCaptureLifecycle(proc: ChildProcessWithoutNullStrea
 			if (!window.isDestroyed()) {
 				window.webContents.send("recording-state-changed", {
 					recording: false,
+					paused: false,
 					sourceName,
 				});
 			}

electron/ipc/register/recording.ts

@@ -391,7 +391,7 @@ async function resolveExistingPath(...candidates: Array<string | null | undefine
 }
 
 export function registerRecordingHandlers(
-	onRecordingStateChange?: (recording: boolean, sourceName: string) => void,
+	onRecordingStateChange?: (recording: boolean, paused: boolean, sourceName: string) => void,
 ) {
 	ipcMain.handle(
 		"start-native-screen-recording",
@@ -1810,7 +1810,7 @@ export function registerRecordingHandlers(
 		}
 	});
 
-	ipcMain.handle("set-recording-state", (_, recording: boolean) => {
+	ipcMain.handle("set-recording-state", (_, recording: boolean, paused = false) => {
 		if (recording) {
 			stopCursorCapture();
 			stopInteractionCapture();
@@ -1844,13 +1844,14 @@ export function registerRecordingHandlers(
 			if (!window.isDestroyed()) {
 				window.webContents.send("recording-state-changed", {
 					recording,
+					paused,
 					sourceName: source.name,
 				});
 			}
 		});
 
 		if (onRecordingStateChange) {
-			onRecordingStateChange(recording, source.name);
+			onRecordingStateChange(recording, paused, source.name);
 		}
 	});
 

electron/ipc/register/settings.ts

@@ -1,14 +1,24 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import fs from "node:fs/promises";
-import { app, ipcMain } from "electron";
+import { app, globalShortcut, ipcMain } from "electron";
 import { hideCursor } from "../../cursorHider";
-import { closeCountdownWindow, createCountdownWindow, getCountdownWindow } from "../../windows";
+import {
+	closeCountdownWindow,
+	createCountdownWindow,
+	getCountdownWindow,
+	getHudOverlayWindow,
+} from "../../windows";
 import {
 	APP_SETTINGS_FILE,
 	COUNTDOWN_SETTINGS_FILE,
 	RECORDINGS_SETTINGS_FILE,
 	SHORTCUTS_FILE,
 } from "../constants";
+import {
+	isLaunchShortcutAction,
+	type LaunchShortcutAction,
+	type ShortcutBinding,
+} from "../shortcutTypes";
 import {
 	countdownCancelled,
 	countdownInProgress,
@@ -64,7 +74,70 @@ function hasAppSetting(store: Record<string, unknown>, key: string): boolean {
 	return Reflect.getOwnPropertyDescriptor(store, key) !== undefined;
 }
 
+let launchShortcutRegisteredAccelerators: string[] = [];
+let launchShortcutWillQuitCleanupRegistered = false;
+
+const ELECTRON_KEY_MAP: Record<string, string> = {
+	arrowup: "Up",
+	arrowdown: "Down",
+	arrowleft: "Left",
+	arrowright: "Right",
+	escape: "Escape",
+	backspace: "Backspace",
+	delete: "Delete",
+	enter: "Enter",
+	tab: "Tab",
+};
+
+function toElectronAccelerator(binding: ShortcutBinding): string | null {
+	const rawKey = binding.key;
+	if (rawKey === " ") {
+		const parts: string[] = [];
+		if (binding.ctrl) parts.push("CommandOrControl");
+		if (binding.shift) parts.push("Shift");
+		if (binding.alt) parts.push("Alt");
+		parts.push("Space");
+		return parts.join("+");
+	}
+
+	const key = rawKey?.trim().toLowerCase();
+	if (!key) {
+		return null;
+	}
+
+	const mappedKey =
+		ELECTRON_KEY_MAP[key] ??
+		(key.length === 1 ? key.toUpperCase() : key.charAt(0).toUpperCase() + key.slice(1));
+	const parts: string[] = [];
+	if (binding.ctrl) parts.push("CommandOrControl");
+	if (binding.shift) parts.push("Shift");
+	if (binding.alt) parts.push("Alt");
+	parts.push(mappedKey);
+	return parts.join("+");
+}
+
+function unregisterLaunchGlobalShortcuts() {
+	for (const accelerator of launchShortcutRegisteredAccelerators) {
+		globalShortcut.unregister(accelerator);
+	}
+	launchShortcutRegisteredAccelerators = [];
+}
+
+function notifyLaunchShortcutTriggered(action: LaunchShortcutAction) {
+	const hud = getHudOverlayWindow();
+	if (!hud || hud.isDestroyed()) {
+		return;
+	}
+
+	hud.webContents.send("launch-shortcut-triggered", action);
+}
+
 export function registerSettingsHandlers() {
+	if (!launchShortcutWillQuitCleanupRegistered) {
+		launchShortcutWillQuitCleanupRegistered = true;
+		app.on("will-quit", unregisterLaunchGlobalShortcuts);
+	}
+
 	ipcMain.handle("app:getVersion", () => {
 		return app.getVersion();
 	});
@@ -139,6 +212,64 @@ export function registerSettingsHandlers() {
 		}
 	});
 
+	ipcMain.handle("register-launch-global-shortcuts", async (_, config: unknown) => {
+		try {
+			unregisterLaunchGlobalShortcuts();
+
+			if (process.platform !== "darwin") {
+				return { success: true, unsupported: true };
+			}
+
+			if (!config || typeof config !== "object") {
+				return { success: true };
+			}
+
+			const failedRegistrations: Array<{
+				action: LaunchShortcutAction;
+				accelerator: string;
+			}> = [];
+
+			for (const [action, binding] of Object.entries(
+				config as Record<string, ShortcutBinding>,
+			)) {
+				if (!isLaunchShortcutAction(action)) {
+					console.warn("Ignoring unknown launch shortcut action in config:", action);
+					continue;
+				}
+
+				const accelerator = toElectronAccelerator(binding);
+				if (!accelerator) {
+					continue;
+				}
+
+				const registered = globalShortcut.register(accelerator, () => {
+					notifyLaunchShortcutTriggered(action);
+				});
+
+				if (registered) {
+					launchShortcutRegisteredAccelerators.push(accelerator);
+				} else {
+					const failedRegistration = { action, accelerator };
+					failedRegistrations.push(failedRegistration);
+					console.warn("Failed to register launch global shortcut:", failedRegistration);
+				}
+			}
+
+			return { success: true, failedRegistrations };
+		} catch (error) {
+			return { success: false, error: String(error) };
+		}
+	});
+
+	ipcMain.handle("unregister-launch-global-shortcuts", async () => {
+		try {
+			unregisterLaunchGlobalShortcuts();
+			return { success: true };
+		} catch (error) {
+			return { success: false, error: String(error) };
+		}
+	});
+
 	// ---------------------------------------------------------------------------
 	// Countdown timer before recording
 	// ---------------------------------------------------------------------------

electron/ipc/shortcutTypes.ts

@@ -0,0 +1,20 @@
+export const LAUNCH_SHORTCUT_ACTIONS = [
+	"startRecording",
+	"stopRecording",
+	"pauseRecording",
+	"resumeRecording",
+	"muteMicrophone",
+] as const;
+
+export type LaunchShortcutAction = (typeof LAUNCH_SHORTCUT_ACTIONS)[number];
+
+export function isLaunchShortcutAction(action: string): action is LaunchShortcutAction {
+	return (LAUNCH_SHORTCUT_ACTIONS as readonly string[]).includes(action);
+}
+
+export type ShortcutBinding = {
+	key: string;
+	ctrl?: boolean;
+	shift?: boolean;
+	alt?: boolean;
+};