diff --git a/scripts/build/build.mts b/scripts/build/build.mts index 0f24f326..59b42587 100644 --- a/scripts/build/build.mts +++ b/scripts/build/build.mts @@ -138,6 +138,12 @@ await Promise.all([ outfile: "dist/js/main.js", footer: { js: "//# sourceURL=VesktopMain" } }), + createContext({ + ...NodeCommonOpts, + entryPoints: ["src/main/keybinds/hookProcess.ts"], + plugins: [uiohookBinaryPlugin], + outfile: "dist/js/hookProcess.js" + }), createContext({ ...NodeCommonOpts, entryPoints: ["src/preload/index.ts"], diff --git a/src/main/keybinds/hook.ts b/src/main/keybinds/hook.ts index 09e80cb3..2ecc324f 100644 --- a/src/main/keybinds/hook.ts +++ b/src/main/keybinds/hook.ts @@ -4,36 +4,17 @@ * SPDX-License-Identifier: GPL-3.0-or-later */ -import { systemPreferences } from "electron"; +import { join } from "path"; + +import { systemPreferences, utilityProcess } from "electron"; import { KeyBind, KeybindStatus, ShortcutAction } from "shared/utils/keybind"; -import type { UiohookKeyboardEvent, UiohookMouseEvent } from "uiohook-napi"; -import { triggerAction } from "./actions"; +import { IS_FLATPAK } from "../constants"; +import { setStatus, triggerAction } from "./actions"; +import { HookInput, HookMessage, startNativeHook } from "./nativeHook"; -type Uiohook = typeof import("uiohook-napi"); -type InputEvent = UiohookKeyboardEvent | UiohookMouseEvent; type ActiveBind = KeyBind & { action: ShortcutAction }; -// uiohook key names that differ from our key names (KeyboardEvent.code with merged modifiers) -const KEY_RENAMES: Record = { - Ctrl: "Control", - CtrlRight: "Control", - AltRight: "Alt", - ShiftRight: "Shift", - MetaRight: "Meta", - // Numpad keys with NumLock off - NumpadInsert: "Numpad0", - NumpadEnd: "Numpad1", - NumpadArrowDown: "Numpad2", - NumpadPageDown: "Numpad3", - NumpadArrowLeft: "Numpad4", - NumpadArrowRight: "Numpad6", - NumpadHome: "Numpad7", - NumpadArrowUp: "Numpad8", - NumpadPageUp: "Numpad9", - NumpadDelete: "NumpadDecimal" -}; - const MODIFIER_FLAGS = { Control: "ctrlKey", Shift: "shiftKey", @@ -41,29 +22,11 @@ const MODIFIER_FLAGS = { Meta: "metaKey" } as const; -let uiohook: Uiohook | null = null; -let keyNames = new Map(); -let running = false; - +let stopInput: (() => void) | null = null; let binds: ActiveBind[] = []; const heldKeys = new Set(); const activeBinds = new Set(); -function toKeyName(uiohookName: string) { - if (/^[A-Z]$/.test(uiohookName)) return "Key" + uiohookName; - if (/^\d$/.test(uiohookName)) return "Digit" + uiohookName; - return KEY_RENAMES[uiohookName] ?? uiohookName; -} - -function loadUiohook() { - if (!uiohook) { - uiohook = require("uiohook-napi") as Uiohook; - keyNames = new Map(Object.entries(uiohook.UiohookKey).map(([name, code]) => [code, toKeyName(name)])); - } - - return uiohook; -} - function press(key: string) { // Held keys repeat their keydown event if (heldKeys.has(key)) return; @@ -93,67 +56,85 @@ function releaseAll() { for (const key of heldKeys) release(key); } -// A modifier release can be missed, for example when the lock screen grabs input. The flags of later events tell us -function syncModifiers(event: InputEvent, key?: string) { +function onInput(input: HookInput) { + const { key, pressed } = input; + + // A modifier release can be missed, e.g. when the lock screen grabs input. for (const [modifier, flag] of Object.entries(MODIFIER_FLAGS)) { - if (modifier !== key && heldKeys.has(modifier) && !event[flag]) release(modifier); + if (modifier !== key && heldKeys.has(modifier) && !input[flag]) { + release(modifier); + } + } + + if (key) { + if (pressed) { + press(key); + } else { + release(key); + } } } -function onKeyDown(event: UiohookKeyboardEvent) { - const key = keyNames.get(event.keycode); - syncModifiers(event, key); - if (key) press(key); +function hookError(message: string) { + console.error("Failed to start input hook:", message); + return { error: `Failed to listen to input: ${message}` }; } -function onKeyUp(event: UiohookKeyboardEvent) { - const key = keyNames.get(event.keycode); - syncModifiers(event, key); - if (key) release(key); -} +function startFlatpakHook() { + // libuiohook can deadlock with Zypak's host preload during dlopen. + const child = utilityProcess.fork(join(__dirname, "hookProcess.js"), [], { + serviceName: "Vesktop Global Keybinds" + }); -// 1 and 2 are left and right click, which we don't allow binding -const mouseKey = (event: UiohookMouseEvent) => { - const button = event.button as number; - return button >= 3 && button <= 5 ? `Mouse${button}` : null; -}; - -function onMouseDown(event: UiohookMouseEvent) { - syncModifiers(event); - const key = mouseKey(event); - if (key) press(key); -} - -function onMouseUp(event: UiohookMouseEvent) { - syncModifiers(event); - const key = mouseKey(event); - if (key) release(key); -} - -function start() { - const { uIOhook } = loadUiohook(); - if (running) return; - - uIOhook.on("keydown", onKeyDown); - uIOhook.on("keyup", onKeyUp); - uIOhook.on("mousedown", onMouseDown); - uIOhook.on("mouseup", onMouseUp); - try { - uIOhook.start(); - } catch (err) { - uIOhook.removeAllListeners(); - throw err; + function fail(message: string) { + stopHook(); + setStatus(hookError(message)); } - running = true; + + const timeout = setTimeout(() => fail("Input hook startup timed out"), 5000); + function stop() { + clearTimeout(timeout); + child.kill(); + } + + child.once("spawn", () => { + if (stopInput !== stop) { + child.kill(); + } + }); + + child.on("message", (message: HookMessage) => { + if (stopInput !== stop) { + return; + } + + switch (message.type) { + case "ready": + clearTimeout(timeout); + break; + case "input": + onInput(message.input); + break; + case "error": + fail(message.message); + break; + } + }); + + child.on("exit", code => { + if (stopInput === stop) { + fail(`Input hook process exited (code ${code})`); + } + }); + + return stop; } export function stopHook() { releaseAll(); - if (!running) return; - - uiohook!.uIOhook.stop(); - uiohook!.uIOhook.removeAllListeners(); - running = false; + const stop = stopInput; + stopInput = null; + stop?.(); } /** Listens for the given binds, only running the input hook while there are any */ @@ -172,10 +153,9 @@ export function setHookBinds(newBinds: KeyBind[]): Omit send({ type: "input", input })); + send({ type: "ready" }); +} catch (error) { + send({ type: "error", message: error instanceof Error ? error.message : String(error) }); +} diff --git a/src/main/keybinds/nativeHook.ts b/src/main/keybinds/nativeHook.ts new file mode 100644 index 00000000..fc234d74 --- /dev/null +++ b/src/main/keybinds/nativeHook.ts @@ -0,0 +1,84 @@ +/* + * Vesktop, a desktop app aiming to give you a snappier Discord Experience + * Copyright (c) 2026 Vendicated and Vesktop contributors + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +import type { UiohookKeyboardEvent, UiohookMouseEvent } from "uiohook-napi"; + +// uiohook key names that differ from our key names (KeyboardEvent.code with merged modifiers) +const KEY_RENAMES: Record = { + Ctrl: "Control", + CtrlRight: "Control", + AltRight: "Alt", + ShiftRight: "Shift", + MetaRight: "Meta", + // Numpad keys with NumLock off + NumpadInsert: "Numpad0", + NumpadEnd: "Numpad1", + NumpadArrowDown: "Numpad2", + NumpadPageDown: "Numpad3", + NumpadArrowLeft: "Numpad4", + NumpadArrowRight: "Numpad6", + NumpadHome: "Numpad7", + NumpadArrowUp: "Numpad8", + NumpadPageUp: "Numpad9", + NumpadDelete: "NumpadDecimal" +}; + +export interface HookInput { + key: string | null; + pressed: boolean; + ctrlKey: boolean; + shiftKey: boolean; + altKey: boolean; + metaKey: boolean; +} + +export type HookMessage = { type: "ready" } | { type: "input"; input: HookInput } | { type: "error"; message: string }; + +function toKeyName(uiohookName: string) { + if (/^[A-Z]$/.test(uiohookName)) { + return "Key" + uiohookName; + } + if (/^\d$/.test(uiohookName)) { + return "Digit" + uiohookName; + } + return KEY_RENAMES[uiohookName] ?? uiohookName; +} + +export function startNativeHook(onInput: (input: HookInput) => void) { + const { UiohookKey, uIOhook } = require("uiohook-napi") as typeof import("uiohook-napi"); + const keyNames = new Map(Object.entries(UiohookKey).map(([name, code]) => [code, toKeyName(name)])); + + function sendInput(key: string | null, pressed: boolean, event: UiohookKeyboardEvent | UiohookMouseEvent) { + const { ctrlKey, shiftKey, altKey, metaKey } = event; + onInput({ key, pressed, ctrlKey, shiftKey, altKey, metaKey }); + } + + function onKeyboard(event: UiohookKeyboardEvent, pressed: boolean) { + sendInput(keyNames.get(event.keycode) ?? null, pressed, event); + } + + function onMouse(event: UiohookMouseEvent, pressed: boolean) { + const button = event.button as number; + // Ignore left and right click, which cannot be bound. + sendInput(button >= 3 && button <= 5 ? `Mouse${button}` : null, pressed, event); + } + + uIOhook.on("keydown", event => onKeyboard(event, true)); + uIOhook.on("keyup", event => onKeyboard(event, false)); + uIOhook.on("mousedown", event => onMouse(event, true)); + uIOhook.on("mouseup", event => onMouse(event, false)); + try { + uIOhook.start(); + } catch (error) { + uIOhook.removeAllListeners(); + throw error; + } + + return () => { + uIOhook.stop(); + uIOhook.removeAllListeners(); + }; +}