Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

fix: register agent hotkey as independent GNOME Wayland keybinding slot

Adrian Lumpe28d8ad59182e
diff --git a/main.js b/main.js
index ed83ef086..48bb15c7d 100644
--- a/main.js
+++ b/main.js
@@ -574,16 +574,31 @@ async function startApp() {
const savedAgentKey = environmentManager.getAgentKey?.() || "";
if (savedAgentKey) {
- hotkeyManager.registerSlot("agent", savedAgentKey, agentHotkeyCallback);
+ const result = await hotkeyManager.registerSlot("agent", savedAgentKey, agentHotkeyCallback);
+ if (!result.success) {
+ debugLogger.warn("Failed to restore agent hotkey", { hotkey: savedAgentKey }, "hotkey");
+ }
}
- ipcMain.on("agent-hotkey-changed", (_event, hotkey) => {
- if (hotkey) {
- hotkeyManager.registerSlot("agent", hotkey, agentHotkeyCallback);
- environmentManager.saveAgentKey(hotkey);
- } else {
- hotkeyManager.unregisterSlot("agent");
- environmentManager.saveAgentKey("");
+ ipcMain.on("agent-hotkey-changed", async (_event, hotkey) => {
+ try {
+ if (hotkey) {
+ const result = await hotkeyManager.registerSlot("agent", hotkey, agentHotkeyCallback);
+ if (result.success) {
+ environmentManager.saveAgentKey(hotkey);
+ } else {
+ debugLogger.warn("Failed to update agent hotkey", { hotkey }, "hotkey");
+ }
+ } else {
+ hotkeyManager.unregisterSlot("agent");
+ environmentManager.saveAgentKey("");
+ }
+ } catch (error) {
+ debugLogger.warn(
+ "Failed to update agent hotkey",
+ { error: error instanceof Error ? error.message : String(error), hotkey },
+ "hotkey"
+ );
}
});
diff --git a/preload.js b/preload.js
index 9e12ea101..7fe0acd58 100644
--- a/preload.js
+++ b/preload.js
@@ -544,6 +544,7 @@ contextBridge.exposeInMainWorld("electronAPI", {
setAutoStartEnabled: (enabled) => ipcRenderer.invoke("set-auto-start-enabled", enabled),
// Agent mode
+ updateAgentHotkey: (hotkey) => ipcRenderer.invoke("update-agent-hotkey", hotkey),
notifyAgentHotkeyChanged: (hotkey) => ipcRenderer.send("agent-hotkey-changed", hotkey),
getAgentKey: () => ipcRenderer.invoke("get-agent-key"),
saveAgentKey: (key) => ipcRenderer.invoke("save-agent-key", key),
diff --git a/src/helpers/gnomeShortcut.js b/src/helpers/gnomeShortcut.js
index e548c8d3d..68028ad0c 100644
--- a/src/helpers/gnomeShortcut.js
+++ b/src/helpers/gnomeShortcut.js
@@ -5,8 +5,18 @@ const DBUS_SERVICE_NAME = "com.openwhispr.App";
const DBUS_OBJECT_PATH = "/com/openwhispr/App";
const DBUS_INTERFACE = "com.openwhispr.App";
-const KEYBINDING_PATH =
- "/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/openwhispr/";
+// Per-slot gsettings paths and display names
+const SLOT_CONFIG = {
+ dictation: {
+ path: "/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/openwhispr/",
+ name: "OpenWhispr Toggle",
+ },
+ agent: {
+ path: "/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/openwhispr-agent/",
+ name: "OpenWhispr Agent",
+ },
+};
+
const KEYBINDING_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys.custom-keybinding";
// Valid pattern for GNOME shortcut format (e.g., "<Alt>r", "<Control><Shift>space")
@@ -40,11 +50,21 @@ function getDBus() {
}
}
+function getSlotConfig(slotName) {
+ const config = SLOT_CONFIG[slotName];
+ if (!config) {
+ throw new Error(`[GnomeShortcut] Unknown slot: "${slotName}"`);
+ }
+ return config;
+}
+
class GnomeShortcutManager {
constructor() {
this.bus = null;
- this.callback = null;
- this.isRegistered = false;
+ this.dictationCallback = null;
+ this.agentCallback = null;
+ // Track which slots have been registered in gsettings
+ this.registeredSlots = new Set();
}
static isGnome() {
@@ -60,8 +80,21 @@ class GnomeShortcutManager {
return process.env.XDG_SESSION_TYPE === "wayland";
}
- async initDBusService(callback) {
- this.callback = callback;
+ /**
+ * Set or update the agent callback after initial D-Bus service initialisation.
+ * This supports the case where the dictation hotkey is set up first and the
+ * agent callback is only available later (after agent window creation).
+ */
+ setAgentCallback(callback) {
+ this.agentCallback = callback;
+ if (this._ifaceRef) {
+ this._ifaceRef._agentCallback = callback;
+ }
+ debugLogger.log("[GnomeShortcut] Agent callback registered");
+ }
+
+ async initDBusService(dictationCallback) {
+ this.dictationCallback = dictationCallback;
const dbusModule = getDBus();
if (!dbusModule) {
@@ -72,8 +105,10 @@ class GnomeShortcutManager {
this.bus = dbusModule.sessionBus();
await this.bus.requestName(DBUS_SERVICE_NAME, 0);
- const InterfaceClass = this._createInterfaceClass(dbusModule, callback);
- const iface = new InterfaceClass();
+ const InterfaceClass = this._createInterfaceClass(dbusModule);
+ const iface = new InterfaceClass(dictationCallback, this.agentCallback);
+ // Keep a reference so setAgentCallback() can update it later
+ this._ifaceRef = iface;
this.bus.export(DBUS_OBJECT_PATH, iface);
debugLogger.log("[GnomeShortcut] D-Bus service initialized successfully");
@@ -88,16 +123,23 @@ class GnomeShortcutManager {
}
}
- _createInterfaceClass(dbusModule, callback) {
+ _createInterfaceClass(dbusModule) {
class OpenWhisprInterface extends dbusModule.interface.Interface {
- constructor() {
+ constructor(dictationCallback, agentCallback) {
super(DBUS_INTERFACE);
- this._callback = callback;
+ this._dictationCallback = dictationCallback;
+ this._agentCallback = agentCallback || null;
}
Toggle() {
- if (this._callback) {
- this._callback();
+ if (this._dictationCallback) {
+ this._dictationCallback();
+ }
+ }
+
+ ToggleAgent() {
+ if (this._agentCallback) {
+ this._agentCallback();
}
}
}
@@ -105,6 +147,7 @@ class GnomeShortcutManager {
OpenWhisprInterface.configureMembers({
methods: {
Toggle: { inSignature: "", outSignature: "" },
+ ToggleAgent: { inSignature: "", outSignature: "" },
},
});
@@ -118,41 +161,47 @@ class GnomeShortcutManager {
return VALID_SHORTCUT_PATTERN.test(shortcut);
}
- async registerKeybinding(shortcut = "<Alt>r") {
+ async registerKeybinding(shortcut = "<Alt>r", slotName = "dictation") {
if (!GnomeShortcutManager.isGnome()) {
debugLogger.log("[GnomeShortcut] Not running on GNOME, skipping registration");
return false;
}
if (!GnomeShortcutManager.isValidShortcut(shortcut)) {
- debugLogger.log(`[GnomeShortcut] Invalid shortcut format: "${shortcut}"`);
+ debugLogger.log(
+ `[GnomeShortcut] Invalid shortcut format: "${shortcut}" for slot "${slotName}"`
+ );
return false;
}
+ const { path: keybindingPath, name: keybindingName } = getSlotConfig(slotName);
+
+ // The dbus-send command for agent uses ToggleAgent, dictation uses Toggle
+ const dbusMethod = slotName === "agent" ? "ToggleAgent" : "Toggle";
+ const command = `dbus-send --session --type=method_call --dest=${DBUS_SERVICE_NAME} ${DBUS_OBJECT_PATH} ${DBUS_INTERFACE}.${dbusMethod}`;
+
try {
const existing = this.getExistingKeybindings();
- const alreadyRegistered = existing.includes(KEYBINDING_PATH);
-
- const command = `dbus-send --session --type=method_call --dest=${DBUS_SERVICE_NAME} ${DBUS_OBJECT_PATH} ${DBUS_INTERFACE}.Toggle`;
+ const alreadyRegistered = existing.includes(keybindingPath);
execFileSync(
"gsettings",
- ["set", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "name", "OpenWhispr Toggle"],
+ ["set", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "name", keybindingName],
{ stdio: "pipe" }
);
execFileSync(
"gsettings",
- ["set", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "binding", shortcut],
+ ["set", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "binding", shortcut],
{ stdio: "pipe" }
);
execFileSync(
"gsettings",
- ["set", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "command", command],
+ ["set", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "command", command],
{ stdio: "pipe" }
);
if (!alreadyRegistered) {
- const newBindings = [...existing, KEYBINDING_PATH];
+ const newBindings = [...existing, keybindingPath];
const bindingsStr = "['" + newBindings.join("', '") + "']";
execFileSync(
"gsettings",
@@ -166,43 +215,57 @@ class GnomeShortcutManager {
);
}
- this.isRegistered = true;
- debugLogger.log(`[GnomeShortcut] Keybinding "${shortcut}" registered successfully`);
+ this.registeredSlots.add(slotName);
+ debugLogger.log(
+ `[GnomeShortcut] Keybinding "${shortcut}" registered for slot "${slotName}" successfully`
+ );
return true;
} catch (err) {
- debugLogger.log("[GnomeShortcut] Failed to register keybinding:", err.message);
+ debugLogger.log(
+ `[GnomeShortcut] Failed to register keybinding for slot "${slotName}":`,
+ err.message
+ );
return false;
}
}
- async updateKeybinding(shortcut) {
- if (!this.isRegistered) {
- return this.registerKeybinding(shortcut);
+ async updateKeybinding(shortcut, slotName = "dictation") {
+ if (!this.registeredSlots.has(slotName)) {
+ return this.registerKeybinding(shortcut, slotName);
}
if (!GnomeShortcutManager.isValidShortcut(shortcut)) {
- debugLogger.log(`[GnomeShortcut] Invalid shortcut format for update: "${shortcut}"`);
+ debugLogger.log(
+ `[GnomeShortcut] Invalid shortcut format for update: "${shortcut}" (slot "${slotName}")`
+ );
return false;
}
+ const { path: keybindingPath } = getSlotConfig(slotName);
+
try {
execFileSync(
"gsettings",
- ["set", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "binding", shortcut],
+ ["set", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "binding", shortcut],
{ stdio: "pipe" }
);
- debugLogger.log(`[GnomeShortcut] Keybinding updated to "${shortcut}"`);
+ debugLogger.log(`[GnomeShortcut] Keybinding updated to "${shortcut}" for slot "${slotName}"`);
return true;
} catch (err) {
- debugLogger.log("[GnomeShortcut] Failed to update keybinding:", err.message);
+ debugLogger.log(
+ `[GnomeShortcut] Failed to update keybinding for slot "${slotName}":`,
+ err.message
+ );
return false;
}
}
- async unregisterKeybinding() {
+ async unregisterKeybinding(slotName = "dictation") {
+ const { path: keybindingPath } = getSlotConfig(slotName);
+
try {
const existing = this.getExistingKeybindings();
- const filtered = existing.filter((p) => p !== KEYBINDING_PATH);
+ const filtered = existing.filter((p) => p !== keybindingPath);
if (filtered.length === 0) {
execFileSync(
@@ -224,21 +287,26 @@ class GnomeShortcutManager {
);
}
- execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "name"], {
+ execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "name"], {
stdio: "pipe",
});
- execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "binding"], {
+ execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "binding"], {
stdio: "pipe",
});
- execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${KEYBINDING_PATH}`, "command"], {
+ execFileSync("gsettings", ["reset", `${KEYBINDING_SCHEMA}:${keybindingPath}`, "command"], {
stdio: "pipe",
});
- this.isRegistered = false;
- debugLogger.log("[GnomeShortcut] Keybinding unregistered successfully");
+ this.registeredSlots.delete(slotName);
+ debugLogger.log(
+ `[GnomeShortcut] Keybinding unregistered for slot "${slotName}" successfully`
+ );
return true;
} catch (err) {
- debugLogger.log("[GnomeShortcut] Failed to unregister keybinding:", err.message);
+ debugLogger.log(
+ `[GnomeShortcut] Failed to unregister keybinding for slot "${slotName}":`,
+ err.message
+ );
return false;
}
}
diff --git a/src/helpers/hotkeyManager.js b/src/helpers/hotkeyManager.js
index 577b71551..9c23d4f78 100644
--- a/src/helpers/hotkeyManager.js
+++ b/src/helpers/hotkeyManager.js
@@ -139,8 +139,49 @@ class HotkeyManager {
return suggestions.filter((s) => s !== failedHotkey).slice(0, 3);
}
- registerSlot(slotName, hotkey, callback) {
+ async registerSlot(slotName, hotkey, callback) {
this.unregisterSlot(slotName);
+
+ // On GNOME Wayland, route non-dictation slots (e.g. "agent") through the
+ // native GNOME keybinding system instead of Electron's globalShortcut,
+ // which does not work under the Wayland security model.
+ if (this.useGnome && this.gnomeManager && slotName !== "dictation") {
+ const gnomeHotkey = GnomeShortcutManager.convertToGnomeFormat(hotkey);
+ if (!gnomeHotkey) {
+ debugLogger.log(
+ `[HotkeyManager] Could not convert hotkey "${hotkey}" to GNOME format for slot "${slotName}"`
+ );
+ return { success: false, error: `Invalid hotkey format for GNOME: "${hotkey}"` };
+ }
+
+ // Register (or update) the agent callback on the shared D-Bus interface
+ if (slotName === "agent") {
+ this.gnomeManager.setAgentCallback(callback);
+ }
+
+ const success = await this.gnomeManager.registerKeybinding(gnomeHotkey, slotName);
+ if (!success) {
+ debugLogger.log(
+ `[HotkeyManager] GNOME keybinding registration failed for slot "${slotName}" ("${hotkey}")`
+ );
+ return {
+ success: false,
+ error: `Failed to register GNOME 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] GNOME slot "${slotName}" set to "${hotkey}" (GNOME format: "${gnomeHotkey}")`
+ );
+ return { success: true, hotkey };
+ }
+
const result = this.setupShortcuts(hotkey, callback, slotName);
if (result.success) {
const slot = this.slots.get(slotName) || {};
@@ -154,6 +195,19 @@ class HotkeyManager {
const slot = this.slots.get(slotName);
if (!slot || !slot.hotkey) return;
+ // On GNOME Wayland, non-dictation slots are managed via gsettings, not globalShortcut
+ if (this.useGnome && this.gnomeManager && slotName !== "dictation") {
+ this.gnomeManager.unregisterKeybinding(slotName).catch((err) => {
+ debugLogger.warn(
+ `[HotkeyManager] Error unregistering GNOME keybinding for slot "${slotName}":`,
+ err.message
+ );
+ });
+ slot.hotkey = null;
+ slot.accelerator = null;
+ return;
+ }
+
const hk = slot.hotkey;
if (!isGlobeLikeHotkey(hk) && !isRightSideModifier(hk) && !isModifierOnlyHotkey(hk)) {
const accel = normalizeToAccelerator(hk);
@@ -591,9 +645,16 @@ class HotkeyManager {
unregisterAll() {
if (this.gnomeManager) {
- this.gnomeManager.unregisterKeybinding().catch((err) => {
- debugLogger.warn("[HotkeyManager] Error unregistering GNOME keybinding:", err.message);
- });
+ // Unregister every slot that was registered via GNOME
+ const gnomeSlots = [...this.gnomeManager.registeredSlots];
+ for (const slotName of gnomeSlots) {
+ this.gnomeManager.unregisterKeybinding(slotName).catch((err) => {
+ debugLogger.warn(
+ `[HotkeyManager] Error unregistering GNOME keybinding for slot "${slotName}":`,
+ err.message
+ );
+ });
+ }
this.gnomeManager.close();
this.gnomeManager = null;
this.useGnome = false;
diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.js
index d95008a0f..f21433a2d 100644
--- a/src/helpers/ipcHandlers.js
+++ b/src/helpers/ipcHandlers.js
@@ -3663,7 +3663,23 @@ class IPCHandlers {
if (!agentCallback) {
return { success: false, message: "Agent hotkey callback not initialized" };
}
- return hotkeyManager.registerSlot("agent", hotkey, agentCallback);
+
+ if (!hotkey) {
+ hotkeyManager.unregisterSlot("agent");
+ this.environmentManager.saveAgentKey?.("");
+ return { success: true, message: "Agent hotkey cleared" };
+ }
+
+ const result = await hotkeyManager.registerSlot("agent", hotkey, agentCallback);
+ if (result.success) {
+ this.environmentManager.saveAgentKey?.(hotkey);
+ return { success: true, message: `Agent hotkey updated to: ${hotkey}` };
+ }
+
+ return {
+ success: false,
+ message: result.error || `Failed to update agent hotkey to: ${hotkey}`,
+ };
});
ipcMain.handle("get-agent-key", async () => {
diff --git a/src/stores/settingsStore.ts b/src/stores/settingsStore.ts
index bfb84313c..f7833a78e 100644
--- a/src/stores/settingsStore.ts
+++ b/src/stores/settingsStore.ts
@@ -486,12 +486,43 @@ export const useSettingsStore = create<SettingsState>()((set, get) => ({
setAgentModel: createStringSetter("agentModel"),
setAgentProvider: createStringSetter("agentProvider"),
setAgentKey: (key: string) => {
- if (isBrowser) localStorage.setItem("agentKey", key);
- useSettingsStore.setState({ agentKey: key });
- if (isBrowser) {
+ if (!isBrowser) {
+ useSettingsStore.setState({ agentKey: key });
+ return;
+ }
+
+ const updateAgentHotkey = window.electronAPI?.updateAgentHotkey;
+ if (!updateAgentHotkey) {
+ localStorage.setItem("agentKey", key);
+ useSettingsStore.setState({ agentKey: key });
window.electronAPI?.notifyAgentHotkeyChanged?.(key);
window.electronAPI?.saveAgentKey?.(key);
+ return;
}
+
+ void updateAgentHotkey(key)
+ .then((result) => {
+ if (!result?.success) {
+ localStorage.setItem("agentKey", "");
+ useSettingsStore.setState({ agentKey: "" });
+ logger.warn(
+ "Failed to update agent hotkey",
+ { hotkey: key, message: result?.message },
+ "settings"
+ );
+ return;
+ }
+
+ localStorage.setItem("agentKey", key);
+ useSettingsStore.setState({ agentKey: key });
+ })
+ .catch((error) => {
+ logger.warn(
+ "Failed to update agent hotkey",
+ { hotkey: key, error: error instanceof Error ? error.message : String(error) },
+ "settings"
+ );
+ });
},
setAgentSystemPrompt: createStringSetter("agentSystemPrompt"),
setAgentEnabled: createBooleanSetter("agentEnabled"),
diff --git a/src/types/electron.ts b/src/types/electron.ts
index c7815b2b3..661096692 100644
--- a/src/types/electron.ts
+++ b/src/types/electron.ts
@@ -933,6 +933,7 @@ declare global {
}>;
// Agent Mode
+ updateAgentHotkey?: (hotkey: string) => Promise<{ success: boolean; message: string }>;
notifyAgentHotkeyChanged?: (hotkey: string) => void;
getAgentKey?: () => Promise<string>;
saveAgentKey?: (key: string) => Promise<void>;