Skip to content

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

fix(hotkeys): release a slot's registered accelerators on unregister

Henry Suda710f26fc6c
diff --git a/src/helpers/hotkeyManager.js b/src/helpers/hotkeyManager.js
index 6931e8223..291ca6c83 100644
--- a/src/helpers/hotkeyManager.js
+++ b/src/helpers/hotkeyManager.js
@@ -324,19 +324,17 @@ class HotkeyManager extends EventEmitter {
return;
}
- for (const hk of slot.hotkeys || []) {
- if (
- !isGlobeLikeHotkey(hk) &&
- !isMouseButtonHotkey(hk) &&
- !isRightSideModifier(hk) &&
- !isModifierOnlyHotkey(hk)
- ) {
- const accel = normalizeToAccelerator(hk);
- try {
- globalShortcut.unregister(accel);
- } catch {
- // already unregistered
- }
+ // Release exactly what was registered. `accelerators` mirrors `hotkeys`
+ // index-for-index and holds null for the entries a native listener owns, so
+ // it cannot drift from the platform rules in _registerSingleHotkey the way
+ // a re-derived list does — modifier-only combos only bypass globalShortcut
+ // on Windows.
+ for (const accel of slot.accelerators || []) {
+ if (!accel) continue;
+ try {
+ globalShortcut.unregister(accel);
+ } catch {
+ // already unregistered
}
}
slot.hotkeys = [];
diff --git a/test/helpers/hotkeySlotUnregister.test.js b/test/helpers/hotkeySlotUnregister.test.js
new file mode 100644
index 000000000..d24c1e003
--- /dev/null
+++ b/test/helpers/hotkeySlotUnregister.test.js
@@ -0,0 +1,94 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+// Stub electron's globalShortcut before hotkeyManager loads so slot
+// registration can run outside Electron. `unregisterCalls` records every
+// accelerator teardown attempts, including ones that were never registered.
+const registered = new Map();
+const unregisterCalls = [];
+require.cache[require.resolve("electron")] = {
+ exports: {
+ globalShortcut: {
+ register(accelerator, callback) {
+ if (registered.has(accelerator)) return false;
+ registered.set(accelerator, callback);
+ return true;
+ },
+ unregister(accelerator) {
+ unregisterCalls.push(accelerator);
+ registered.delete(accelerator);
+ },
+ isRegistered(accelerator) {
+ return registered.has(accelerator);
+ },
+ unregisterAll() {
+ registered.clear();
+ },
+ },
+ BrowserWindow: class {},
+ },
+};
+
+const HotkeyManager = require("../../src/helpers/hotkeyManager.js");
+
+const noop = () => {};
+
+test.beforeEach(() => {
+ registered.clear();
+ unregisterCalls.length = 0;
+});
+
+test("unregisterSlot releases every accelerator the slot registered", async () => {
+ const manager = new HotkeyManager();
+
+ // "Control+Alt" is modifier-only. Only Windows diverts those to the native
+ // low-level listener; everywhere else globalShortcut owns them, so the
+ // teardown has to release them too.
+ await manager.registerSlot("agent", "F7,Control+Alt", noop);
+ const heldAfterRegister = [...registered.keys()];
+
+ manager.unregisterSlot("agent");
+
+ assert.deepEqual(
+ [...registered.keys()],
+ [],
+ `slot teardown left accelerators registered (held after register: ${heldAfterRegister.join(", ")})`
+ );
+ assert.deepEqual(manager.getSlotHotkeys("agent"), []);
+});
+
+test("a combo freed by unregisterSlot can be registered again", async () => {
+ const manager = new HotkeyManager();
+
+ await manager.registerSlot("agent", "Control+Alt", noop, { atomic: true });
+ manager.unregisterSlot("agent");
+
+ const reregistered = await manager.registerSlot("agent", "Control+Alt", noop, { atomic: true });
+ assert.equal(reregistered.success, true);
+ assert.deepEqual(manager.getSlotHotkeys("agent"), ["Control+Alt"]);
+});
+
+test("unregisterSlot never releases an accelerator the slot does not own", async () => {
+ const manager = new HotkeyManager();
+
+ await manager.registerSlot("agent", "F7", noop, { atomic: true });
+ await manager.registerSlot("cancel", "F8", noop, { atomic: true });
+
+ manager.unregisterSlot("agent");
+
+ assert.deepEqual(unregisterCalls, ["F7"]);
+ assert.deepEqual([...registered.keys()], ["F8"]);
+ assert.deepEqual(manager.getSlotHotkeys("cancel"), ["F8"]);
+});
+
+test("unregisterSlot on an already-cleared slot is a no-op", async () => {
+ const manager = new HotkeyManager();
+
+ await manager.registerSlot("agent", "F7", noop, { atomic: true });
+ manager.unregisterSlot("agent");
+ unregisterCalls.length = 0;
+
+ manager.unregisterSlot("agent");
+
+ assert.deepEqual(unregisterCalls, []);
+});