Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
Add KDE Wayland native hotkey support and fix clipboard paste
Alcahest969299b56a80
diff --git a/electron-builder.json b/electron-builder.jsonindex ca991b9aa..6fe394346 100644--- a/electron-builder.json+++ b/electron-builder.json@@ -174,7 +174,11 @@"--deb-suggests","wtype","--deb-recommends",- "wl-clipboard"+ "wl-clipboard",+ "--deb-recommends",+ "xclip",+ "--deb-suggests",+ "xsel"]},"rpm": {@@ -190,7 +194,11 @@"--rpm-tag","Suggests: wtype","--rpm-tag",- "Recommends: wl-clipboard"+ "Recommends: wl-clipboard",+ "--rpm-tag",+ "Recommends: xclip",+ "--rpm-tag",+ "Suggests: xsel"]},"nsis": {diff --git a/main.js b/main.jsindex 271623a4c..5bd5431a7 100644--- a/main.js+++ b/main.js@@ -76,10 +76,9 @@ if (process.platform === "win32") {}// Enable native Wayland support: Ozone platform for native rendering.-// KDE is forced to XWayland because globalShortcut doesn't work on native-// Wayland without the GlobalShortcuts portal, and the portal causes unwanted-// permission dialogs with broken hotkey registration.-// GNOME and Hyprland use their own D-Bus shortcut managers so they're fine.+// KDE uses XWayland for reliable clipboard access (Wayland restricts clipboard+// to focused windows), with KGlobalAccel D-Bus for global shortcuts.+// GNOME and Hyprland run native Wayland with their own D-Bus shortcut managers.if (process.platform === "linux" && process.env.XDG_SESSION_TYPE === "wayland") {const desktop = (process.env.XDG_CURRENT_DESKTOP || "").toLowerCase();if (desktop.includes("kde")) {diff --git a/src/components/SettingsPage.tsx b/src/components/SettingsPage.tsxindex 15fef8963..2afe2f6eb 100644--- a/src/components/SettingsPage.tsx+++ b/src/components/SettingsPage.tsx@@ -794,6 +794,9 @@ export default function SettingsPage({ activeSection = "general" }: SettingsPagehasUdevRule: boolean;hasGroup: boolean;allGood: boolean;+ isKde?: boolean;+ hasXclip?: boolean;+ hasXsel?: boolean;} | null>(null);const [ydotoolGuideKey, setYdotoolGuideKey] = useState<string | null>(null);@@ -2605,6 +2608,28 @@ EOF`,},];+ if (ydotoolStatus.isKde) {+ checks.push({+ key: "hasXclip",+ label: "xclip",+ ok: ydotoolStatus.hasXclip || ydotoolStatus.hasXsel || false,+ desc: t("settingsPage.general.waylandPaste.xclipDesc", {+ defaultValue: "Clipboard tool for KDE Wayland paste (xclip or xsel)",+ }),+ guide: [+ {+ title: t("settingsPage.general.waylandPaste.guide.xclip.step1Title", {+ defaultValue: "Install xclip",+ }),+ cmds: [+ { cmd: "sudo dnf install xclip # Fedora" },+ { cmd: "sudo apt install xclip # Debian/Ubuntu" },+ ],+ },+ ],+ });+ }+const allOk = checks.every((c) => c.ok);const activeGuide = checks.find((c) => c.key === ydotoolGuideKey);diff --git a/src/helpers/clipboard.js b/src/helpers/clipboard.jsindex d8f294132..3a89672cd 100644--- a/src/helpers/clipboard.js+++ b/src/helpers/clipboard.js@@ -98,6 +98,40 @@ class ClipboardManager {}_writeClipboardWayland(text, webContents) {+ const { isKde } = getLinuxSessionInfo();++ // On KDE with XWayland, write to X11 clipboard directly because+ // wl-copy targets the Wayland clipboard which is desynced from X11+ if (isKde) {+ if (this.commandExists("xclip")) {+ try {+ const result = spawnSync("xclip", ["-selection", "clipboard"], {+ input: text,+ timeout: 200,+ });+ if (result.status === 0) {+ clipboard.writeText(text);+ return;+ }+ } catch {}+ }+ if (this.commandExists("xsel")) {+ try {+ const result = spawnSync("xsel", ["--clipboard", "--input"], {+ input: text,+ timeout: 200,+ });+ if (result.status === 0) {+ clipboard.writeText(text);+ return;+ }+ } catch {}+ }+ // Last resort: Electron's clipboard.writeText should work on XWayland+ clipboard.writeText(text);+ return;+ }+if (this.commandExists("wl-copy")) {try {const isHyprland = !!process.env.HYPRLAND_INSTANCE_SIGNATURE;@@ -1112,11 +1146,12 @@ class ClipboardManager {});if (isWayland) {- // On KDE Wayland, uinput works reliably for all apps (including- // Chromium/Electron which ignore RemoteDesktop portal keystrokes).+ // On KDE with XWayland (ozone-platform-hint: x11), portal paste works+ // because clipboard and input are both on X11. uinput causes a clipboard+ // desync (X11 clipboard vs Wayland input) so portal is preferred.// On GNOME, Mutter doesn't reliably route uinput to native Wayland- // windows (issue #292), so portal is tried first there.- const preferUinput = isKde;+ // windows (issue #292), so portal is tried first there too.+ const preferUinput = false;const tryUinputPaste = async () => {const args = ["--uinput"];diff --git a/src/helpers/hotkeyManager.js b/src/helpers/hotkeyManager.jsindex a20dbc665..5c042965f 100644--- a/src/helpers/hotkeyManager.js+++ b/src/helpers/hotkeyManager.js@@ -2,6 +2,7 @@ const { globalShortcut } = require("electron");const debugLogger = require("./debugLogger");const GnomeShortcutManager = require("./gnomeShortcut");const HyprlandShortcutManager = require("./hyprlandShortcut");+const KDEShortcutManager = require("./kdeShortcut");const { i18nMain } = require("./i18nMain");// Delay to ensure localStorage is accessible after window load@@ -68,6 +69,8 @@ class HotkeyManager {this.useGnome = false;this.hyprlandManager = null;this.useHyprland = false;+ this.kdeManager = null;+ this.useKDE = false;}// Backward-compatible property accessors@@ -185,6 +188,35 @@ class HotkeyManager {return { success: true, hotkey };}+ // On KDE Wayland, route all slots through KGlobalAccel D-Bus+ if (this.useKDE && this.kdeManager) {+ if (slotName === "agent") {+ this.kdeManager.setAgentCallback(callback);+ }++ const success = await this.kdeManager.registerKeybinding(hotkey, slotName, callback);+ if (!success) {+ debugLogger.log(+ `[HotkeyManager] KDE keybinding registration failed for slot "${slotName}" ("${hotkey}")`+ );+ return {+ success: false,+ error: `Failed to register KDE hotkey "${hotkey}" for ${slotName}`,+ };+ }++ const slot = this.slots.get(slotName) || { hotkey: null, callback: null, accelerator: null };+ slot.hotkey = hotkey;+ slot.callback = callback;+ slot.accelerator = null;+ this.slots.set(slotName, slot);++ debugLogger.log(+ `[HotkeyManager] KDE slot "${slotName}" set to "${hotkey}"`+ );+ return { success: true, hotkey };+ }+const result = this.setupShortcuts(hotkey, callback, slotName);if (result.success) {const slot = this.slots.get(slotName) || {};@@ -198,6 +230,19 @@ class HotkeyManager {const slot = this.slots.get(slotName);if (!slot || !slot.hotkey) return;+ // On KDE Wayland, all slots are managed via KGlobalAccel+ if (this.useKDE && this.kdeManager) {+ this.kdeManager.unregisterKeybinding(slotName).catch((err) => {+ debugLogger.warn(+ `[HotkeyManager] Error unregistering KDE keybinding for slot "${slotName}":`,+ err.message+ );+ });+ slot.hotkey = null;+ slot.accelerator = null;+ return;+ }+// On GNOME Wayland, non-dictation slots are managed via gsettings, not globalShortcutif (this.useGnome && this.gnomeManager && slotName !== "dictation") {this.gnomeManager.unregisterKeybinding(slotName).catch((err) => {@@ -437,6 +482,29 @@ class HotkeyManager {return false;}+ async initializeKDEShortcuts(callback) {+ if (process.platform !== "linux" || !KDEShortcutManager.isWayland() || !KDEShortcutManager.isKDE()) {+ return false;+ }++ try {+ this.kdeManager = new KDEShortcutManager();+ const ok = await this.kdeManager.init();+ if (ok) {+ this.useKDE = true;+ this.hotkeyCallback = callback;+ debugLogger.log("[HotkeyManager] KDE Wayland shortcuts initialized via KGlobalAccel D-Bus");+ return true;+ }+ } catch (err) {+ debugLogger.log("[HotkeyManager] KDE shortcut init failed:", err.message);+ this.kdeManager = null;+ this.useKDE = false;+ }++ return false;+ }+async initializeHyprlandShortcuts(callback) {const isLinux = process.platform === "linux";const isWayland = HyprlandShortcutManager.isWayland();@@ -525,7 +593,45 @@ class HotkeyManager {return;}- // Try Hyprland native shortcuts if GNOME path was not applicable+ // Try KDE native shortcuts via KGlobalAccel+ const kdeOk = await this.initializeKDEShortcuts(callback);++ if (kdeOk) {+ const registerKDEHotkey = async () => {+ try {+ const savedHotkey = await mainWindow.webContents.executeJavaScript(`+ localStorage.getItem("dictationKey") || ""+ `);+ const hotkey = savedHotkey && savedHotkey.trim() !== "" ? savedHotkey : "Control+Super";+ const success = await this.kdeManager.registerKeybinding(hotkey, "dictation", callback);+ if (success) {+ this.currentHotkey = hotkey;+ debugLogger.log(+ `[HotkeyManager] KDE hotkey "${hotkey}" registered successfully`+ );+ } else {+ debugLogger.log(+ "[HotkeyManager] KDE keybinding failed, falling back to globalShortcut"+ );+ this.useKDE = false;+ this.loadSavedHotkeyOrDefault(mainWindow, callback);+ }+ } catch (err) {+ debugLogger.log(+ "[HotkeyManager] KDE keybinding failed, falling back to globalShortcut:",+ err.message+ );+ this.useKDE = false;+ this.loadSavedHotkeyOrDefault(mainWindow, callback);+ }+ };++ setTimeout(registerKDEHotkey, HOTKEY_REGISTRATION_DELAY_MS);+ this.isInitialized = true;+ return;+ }++ // Try Hyprland native shortcuts if GNOME/KDE paths were not applicableconst hyprlandOk = await this.initializeHyprlandShortcuts(callback);if (hyprlandOk) {@@ -796,6 +902,20 @@ class HotkeyManager {this.gnomeManager = null;this.useGnome = false;}+ if (this.kdeManager) {+ const kdeSlots = [...this.kdeManager.registeredSlots];+ for (const slotName of kdeSlots) {+ this.kdeManager.unregisterKeybinding(slotName).catch((err) => {+ debugLogger.warn(+ `[HotkeyManager] Error unregistering KDE keybinding for slot "${slotName}":`,+ err.message+ );+ });+ }+ this.kdeManager.close();+ this.kdeManager = null;+ this.useKDE = false;+ }if (this.hyprlandManager) {this.hyprlandManager.unregisterKeybinding().catch((err) => {debugLogger.warn("[HotkeyManager] Error unregistering Hyprland keybinding:", err.message);@@ -822,8 +942,12 @@ class HotkeyManager {return this.useHyprland;}+ isUsingKDE() {+ return this.useKDE;+ }+isUsingNativeShortcut() {- return this.useGnome || this.useHyprland;+ return this.useGnome || this.useHyprland || this.useKDE;}isHotkeyRegistered(hotkey) {diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.jsindex 8e67af09d..1aa0f66cb 100644--- a/src/helpers/ipcHandlers.js+++ b/src/helpers/ipcHandlers.js@@ -1384,6 +1384,7 @@ class IPCHandlers {return {isUsingGnome: this.windowManager.isUsingGnomeHotkeys(),isUsingHyprland: this.windowManager.isUsingHyprlandHotkeys(),+ isUsingKDE: this.windowManager.isUsingKDEHotkeys?.() || false,isUsingNativeShortcut: this.windowManager.isUsingNativeShortcutHotkeys(),};});@@ -3354,7 +3355,14 @@ class IPCHandlers {ipcMain.handle("get-ydotool-status", () => {const { getYdotoolStatus } = require("./ensureYdotool");- return getYdotoolStatus();+ const status = getYdotoolStatus();+ const { execFileSync } = require("child_process");+ const isKde = (process.env.XDG_CURRENT_DESKTOP || "").toLowerCase().includes("kde");+ let hasXclip = false;+ let hasXsel = false;+ try { execFileSync("which", ["xclip"], { timeout: 1000 }); hasXclip = true; } catch {}+ try { execFileSync("which", ["xsel"], { timeout: 1000 }); hasXsel = true; } catch {}+ return { ...status, isKde, hasXclip, hasXsel };});ipcMain.handle("get-debug-state", async () => {diff --git a/src/helpers/kdeShortcut.js b/src/helpers/kdeShortcut.jsnew file mode 100644index 000000000..1746bffd6--- /dev/null+++ b/src/helpers/kdeShortcut.js@@ -0,0 +1,238 @@+const debugLogger = require("./debugLogger");++let dbus = null;++function getDBus() {+ if (dbus) return dbus;+ try {+ dbus = require("dbus-next");+ return dbus;+ } catch (err) {+ debugLogger.log("[KDEShortcut] Failed to load dbus-next:", err.message);+ return null;+ }+}++// Qt::Key and Qt::KeyboardModifier values for KGlobalAccel+const QT_MODIFIERS = {+ control: 0x04000000,+ ctrl: 0x04000000,+ alt: 0x08000000,+ shift: 0x02000000,+ super: 0x10000000,+ meta: 0x10000000,+ commandorcontrol: 0x04000000,+};++const QT_KEYS = {+ a: 0x41, b: 0x42, c: 0x43, d: 0x44, e: 0x45, f: 0x46, g: 0x47, h: 0x48,+ i: 0x49, j: 0x4a, k: 0x4b, l: 0x4c, m: 0x4d, n: 0x4e, o: 0x4f, p: 0x50,+ q: 0x51, r: 0x52, s: 0x53, t: 0x54, u: 0x55, v: 0x56, w: 0x57, x: 0x58,+ y: 0x59, z: 0x5a,+ 0: 0x30, 1: 0x31, 2: 0x32, 3: 0x33, 4: 0x34,+ 5: 0x35, 6: 0x36, 7: 0x37, 8: 0x38, 9: 0x39,+ f1: 0x01000030, f2: 0x01000031, f3: 0x01000032, f4: 0x01000033,+ f5: 0x01000034, f6: 0x01000035, f7: 0x01000036, f8: 0x01000037,+ f9: 0x01000038, f10: 0x01000039, f11: 0x0100003a, f12: 0x0100003b,+ space: 0x20, tab: 0x01000001, escape: 0x01000000, backspace: 0x01000003,+ enter: 0x01000005, return: 0x01000004,+ insert: 0x01000006, delete: 0x01000007,+ home: 0x01000010, end: 0x01000011,+ pageup: 0x01000016, pagedown: 0x01000017,+ up: 0x01000013, down: 0x01000015, left: 0x01000012, right: 0x01000014,+ "`": 0x60, grave: 0x60,+ print: 0x01000009, scrolllock: 0x01000026, pause: 0x01000008,+};++const COMPONENT_NAME = "openwhispr";++class KDEShortcutManager {+ constructor() {+ this.bus = null;+ this.kglobalaccel = null;+ this.componentProxy = null;+ this.callbacks = new Map();+ this.registeredSlots = new Set();+ }++ static isKDE() {+ const desktop = (process.env.XDG_CURRENT_DESKTOP || "").toLowerCase();+ return desktop.includes("kde");+ }++ static isWayland() {+ return process.env.XDG_SESSION_TYPE === "wayland";+ }++ static convertToQtKeyCode(electronHotkey) {+ const parts = electronHotkey.split("+");+ let qtKey = 0;++ for (const part of parts) {+ const lower = part.toLowerCase().trim();+ if (QT_MODIFIERS[lower]) {+ qtKey |= QT_MODIFIERS[lower];+ } else {+ const key = QT_KEYS[lower] || QT_KEYS[lower.replace("arrow", "")];+ if (key) {+ qtKey |= key;+ } else {+ debugLogger.log(`[KDEShortcut] Unknown key: "${part}"`);+ return null;+ }+ }+ }++ return qtKey;+ }++ async init() {+ const dbusModule = getDBus();+ if (!dbusModule) return false;++ try {+ this.bus = dbusModule.sessionBus();+ const proxy = await this.bus.getProxyObject(+ "org.kde.kglobalaccel",+ "/kglobalaccel"+ );+ this.kglobalaccel = proxy.getInterface("org.kde.KGlobalAccel");++ debugLogger.log("[KDEShortcut] Connected to KGlobalAccel D-Bus");+ return true;+ } catch (err) {+ debugLogger.log("[KDEShortcut] Failed to connect:", err.message);+ this.bus = null;+ this.kglobalaccel = null;+ return false;+ }+ }++ async _listenForComponent() {+ if (this.componentProxy) return;++ try {+ const componentPath = `/component/${COMPONENT_NAME}`;+ const proxy = await this.bus.getProxyObject(+ "org.kde.kglobalaccel",+ componentPath+ );+ const iface = proxy.getInterface("org.kde.kglobalaccel.Component");++ iface.on("globalShortcutPressed", (componentUnique, shortcutUnique, timestamp) => {+ debugLogger.log("[KDEShortcut] Shortcut pressed", { componentUnique, shortcutUnique });+ // KGlobalAccel may send actionUnique or actionFriendly depending on version+ const callback = this.callbacks.get(shortcutUnique)+ || this._findCallbackByFriendlyName(shortcutUnique);+ if (callback) {+ callback();+ } else {+ debugLogger.log("[KDEShortcut] No callback found for", { shortcutUnique, registered: [...this.callbacks.keys()] });+ }+ });++ this.componentProxy = iface;+ debugLogger.log("[KDEShortcut] Listening for globalShortcutPressed on", componentPath);+ } catch (err) {+ debugLogger.log("[KDEShortcut] Failed to listen on component:", err.message);+ }+ }++ _findCallbackByFriendlyName(name) {+ // Map friendly names back to slot names+ const friendlyToSlot = {};+ for (const slotName of this.registeredSlots) {+ friendlyToSlot[`OpenWhispr ${slotName}`] = slotName;+ friendlyToSlot[`OpenWhispr`] = "dictation"; // legacy compat+ }+ const slotName = friendlyToSlot[name];+ return slotName ? this.callbacks.get(slotName) : null;+ }++ setAgentCallback(callback) {+ this.callbacks.set("agent", callback);+ debugLogger.log("[KDEShortcut] Agent callback set");+ }++ async registerKeybinding(electronHotkey, slotName = "dictation", callback) {+ if (!this.kglobalaccel) return false;++ const qtKey = KDEShortcutManager.convertToQtKeyCode(electronHotkey);+ if (qtKey === null) {+ debugLogger.log(`[KDEShortcut] Could not convert "${electronHotkey}" to Qt key code`);+ return false;+ }++ // actionId: [componentUnique, componentFriendly, actionUnique, actionFriendly]+ const actionId = [+ COMPONENT_NAME,+ "OpenWhispr",+ slotName,+ `OpenWhispr ${slotName}`,+ ];++ try {+ // Register action then set shortcut+ await this.kglobalaccel.doRegister(actionId);+ const result = await this.kglobalaccel.setShortcut(actionId, [qtKey], 0x02);++ if (callback) this.callbacks.set(slotName, callback);+ this.registeredSlots.add(slotName);++ // Start listening for press events on the component+ await this._listenForComponent();++ debugLogger.log("[KDEShortcut] Registered", {+ slot: slotName,+ hotkey: electronHotkey,+ qtKey: `0x${qtKey.toString(16)}`,+ result,+ });+ return true;+ } catch (err) {+ debugLogger.log(`[KDEShortcut] Registration failed for "${slotName}":`, err.message);+ return false;+ }+ }++ async unregisterKeybinding(slotName = "dictation") {+ if (!this.kglobalaccel) return;++ const actionId = [+ COMPONENT_NAME,+ "OpenWhispr",+ slotName,+ `OpenWhispr ${slotName}`,+ ];++ try {+ await this.kglobalaccel.unRegister(actionId);+ this.callbacks.delete(slotName);+ this.registeredSlots.delete(slotName);+ debugLogger.log("[KDEShortcut] Unregistered", { slot: slotName });+ } catch (err) {+ debugLogger.log(`[KDEShortcut] Unregister failed for "${slotName}":`, err.message);+ }+ }++ close() {+ // Unregister all before closing+ for (const slotName of this.registeredSlots) {+ const actionId = [COMPONENT_NAME, "OpenWhispr", slotName, `OpenWhispr ${slotName}`];+ try {+ this.kglobalaccel?.unRegister(actionId);+ } catch {}+ }++ if (this.bus) {+ try { this.bus.disconnect(); } catch {}+ this.bus = null;+ this.kglobalaccel = null;+ this.componentProxy = null;+ }+ this.callbacks.clear();+ this.registeredSlots.clear();+ }+}++module.exports = KDEShortcutManager;diff --git a/src/helpers/windowManager.js b/src/helpers/windowManager.jsindex 8d3f64946..4803f0ef2 100644--- a/src/helpers/windowManager.js+++ b/src/helpers/windowManager.js@@ -495,6 +495,10 @@ class WindowManager {return this.hotkeyManager.isUsingHyprland();}+ isUsingKDEHotkeys() {+ return this.hotkeyManager.isUsingKDE();+ }+isUsingNativeShortcutHotkeys() {return this.hotkeyManager.isUsingNativeShortcut();}