qdesk 1.0.10 → 1.0.12

package/dist/bank/key-bindings.js

@@ -0,0 +1,64 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+const STORAGE_FILE = path.join(os.tmpdir(), "qdesk.bindings");
+export class KeyBindings {
+    bindings = new Map();
+    constructor() {
+        const loaded = load();
+        for (const { chord, info } of loaded) {
+            this.bindings.set(chord, info);
+        }
+    }
+    get(chord) {
+        return this.bindings.get(chord);
+    }
+    set(chord, info) {
+        this.bindings.set(chord, info);
+        console.log(`[add] Bound ${chord} -> "${info.name}"`);
+        save(this.bindings);
+    }
+    delete(chord) {
+        const output = this.bindings.delete(chord);
+        if (output) {
+            console.log(`[remove] Unbound ${chord}`);
+        }
+        else {
+            console.log(`[remove] No binding exists for ${chord}`);
+        }
+        save(this.bindings);
+        return output;
+    }
+    get size() {
+        return this.bindings.size;
+    }
+    entries() {
+        return this.bindings.entries();
+    }
+}
+function load() {
+    try {
+        const raw = fs.readFileSync(STORAGE_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.map(({ chord, info }) => ({
+            chord,
+            info: {
+                handle: BigInt(info.handle),
+                name: info.name,
+            },
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function save(bindings) {
+    const data = Array.from(bindings.entries()).map(([chord, info]) => ({
+        chord,
+        info: {
+            handle: info.handle.toString(),
+            name: info.name,
+        },
+    }));
+    fs.writeFileSync(STORAGE_FILE, JSON.stringify(data), "utf8");
+}

package/dist/index.js

@@ -1,72 +1,32 @@
 #!/usr/bin/env node
-import { readFileSync } from "node:fs";
-import process from "node:process";
-import { normalizeChord, startListening } from "./chord-utils.js";
-import { setScreenHue } from "./screen-hue.js";
-import { activateWindowByHandle, getActiveWindowHandleAndName, } from "./window-utils.js";
-// Configure this chord at the top of file.
-const DEFAULT_ADD_CHORD = "win+ctrl+a";
-const DEFAULT_DROP_CHORD = "win+ctrl+d";
-function hasCliFlag(flag) {
-    return process.argv.slice(2).includes(flag);
-}
-function getPackageVersion() {
-    try {
-        const packageJson = readFileSync(new URL("../package.json", import.meta.url), "utf8");
-        const parsed = JSON.parse(packageJson);
-        return parsed.version ?? "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
-function setTerminalTitle(title) {
-    process.title = title;
-    if (process.stdout.isTTY) {
-        process.stdout.write(`\u001b]0;${title}\u0007`);
-    }
-}
-if (hasCliFlag("--version") || hasCliFlag("-v")) {
-    console.log(getPackageVersion());
-    process.exit(0);
-}
-setTerminalTitle("qdesk");
-function normalizeChordInput(chord) {
-    return normalizeChord(chord.trim().toLowerCase());
-}
-function getCliArgValue(flag) {
-    const args = process.argv.slice(2);
-    const exact = args.find((arg) => arg.startsWith(`${flag}=`));
-    if (exact) {
-        return exact.slice(flag.length + 1);
-    }
-    const idx = args.indexOf(flag);
-    if (idx >= 0 && idx + 1 < args.length) {
-        return args[idx + 1];
-    }
-    return undefined;
-}
-const ADD_CHORD = normalizeChordInput(getCliArgValue("-a") ?? DEFAULT_ADD_CHORD);
-const DROP_CHORD = normalizeChordInput(getCliArgValue("-d") ?? DEFAULT_DROP_CHORD);
+import { startListening } from "./koffi/chord-listener.js";
+import { setScreenHue } from "./koffi/screen-hue.js";
+import { activateWindowByHandle, checkIfWindowExists, getActiveWindowHandleAndName, } from "./koffi/window-utils.js";
+import { ensureSingleProcess } from "./process/process-deduplication.js";
+import { getCliArgStuff } from "./process/cli.js";
+import { KeyBindings } from "./bank/key-bindings.js";
+import { logInfo, logSwitch, logWarn } from "./log/log.js";
+ensureSingleProcess();
+const { ADD_CHORD, DROP_CHORD } = getCliArgStuff();
 if (ADD_CHORD === DROP_CHORD) {
-    console.warn(`[warn] add and drop chords are identical (${ADD_CHORD}); behavior may conflict.`);
+    logWarn(`add and drop chords are identical (${ADD_CHORD}); behavior may conflict.`);
 }
-const bindings = new Map();
 let activeRecording;
 let awaitingChordRemoval = false;
 const toolWindowAtStartup = getActiveWindowHandleAndName() ?? undefined;
-console.log("[info] Tool window at startup:", toolWindowAtStartup?.name ?? "(unknown)");
-const listener = startListening({
+logInfo(`Tool window at startup: ${toolWindowAtStartup?.name ?? "(unknown)"}`);
+const bindings = new KeyBindings();
+startListening({
     onEscape: (stopPropagating) => {
         if (!activeRecording && !awaitingChordRemoval) {
             return;
         }
         if (activeRecording) {
-            console.log("[add] Canceled recording mode via Escape.");
+            logInfo("Canceled recording mode via Escape.");
             activeRecording = undefined;
         }
         if (awaitingChordRemoval) {
-            console.log("[drop] Canceled removal mode via Escape.");
+            logInfo("Canceled removal mode via Escape.");
             awaitingChordRemoval = false;
         }
         setScreenHue("off");
@@ -77,11 +37,10 @@ const listener = startListening({
         // recording
         if (activeRecording) {
             if ([ADD_CHORD, DROP_CHORD].includes(chord)) {
-                console.warn(`[warn] Ignoring ${chord} chord during active recording to avoid conflicts.`);
+                logWarn(`Ignoring ${chord} chord during active recording to avoid conflicts.`);
                 return stopPropagating();
             }
             bindings.set(chord, activeRecording);
-            console.log(`[add] Bound ${chord} -> "${activeRecording.name}"`);
             activeRecording = undefined;
             setScreenHue("off");
             printBindings();
@@ -91,12 +50,7 @@ const listener = startListening({
         if (awaitingChordRemoval) {
             awaitingChordRemoval = false;
             setScreenHue("off");
-            if (bindings.delete(chord)) {
-                console.log(`[drop] Removed binding for ${chord}`);
-            }
-            else {
-                console.log(`[drop] No binding exists for ${chord}`);
-            }
+            bindings.delete(chord);
             printBindings();
             return stopPropagating();
         }
@@ -106,10 +60,10 @@ const listener = startListening({
             setScreenHue("off");
             activeRecording = getActiveWindowHandleAndName();
             if (!activeRecording) {
-                console.warn("[warn] No foreground window found to bind.");
+                logWarn("No foreground window found to bind.");
             }
             else {
-                console.log(`[add] Armed for "${activeRecording.name}". Waiting for next chord...`);
+                logInfo(`Armed for "${activeRecording.name}". Waiting for next chord... (Esc to cancel)`);
                 setScreenHue("record");
             }
             return stopPropagating();
@@ -124,7 +78,7 @@ const listener = startListening({
             if (toolWindowAtStartup) {
                 activateWindowByHandle(toolWindowAtStartup.handle);
             }
-            console.log("[drop] Armed. Press the chord you want to remove.");
+            logInfo("Armed for removal. Press the chord you want to remove. (Esc to cancel)");
             printBindings();
             setScreenHue("remove");
             return stopPropagating();
@@ -134,14 +88,26 @@ const listener = startListening({
         if (binding) {
             const result = activateWindowByHandle(binding.handle);
             if (result === "missing") {
-                console.error(`[switch ${chord}] Window "${binding.name}" no longer exists, clearing binding.`);
+                logSwitch({
+                    chord,
+                    name: binding.name,
+                    type: "missing",
+                });
                 bindings.delete(chord);
             }
             else if (result === "activated") {
-                console.log(`[switch ${chord}] Switched to "${binding.name}"`);
+                logSwitch({
+                    chord,
+                    name: binding.name,
+                    type: "success",
+                });
             }
             else {
-                console.warn(`[switch ${chord}] Activation failed for "${binding.name}"`);
+                logSwitch({
+                    chord,
+                    name: binding.name,
+                    type: "failed",
+                });
             }
             return stopPropagating();
         }
@@ -153,7 +119,7 @@ function printBindings() {
         console.log("  (none)");
     }
     else {
-        for (const [chord, window] of bindings) {
+        for (const [chord, window] of bindings.entries()) {
             console.log(`  ${chord} -> "${window.name}"`);
         }
     }
@@ -163,4 +129,11 @@ console.log("[qdesk] Starting...");
 console.log(`  Adding a chord: ${ADD_CHORD}`);
 console.log(`  Dropping a chord: ${DROP_CHORD}`);
 console.log("  CLI overrides: -a <combo>, -d <combo>");
-listener.runMessageLoop();
+for (const [chord, window] of bindings.entries()) {
+    if (!checkIfWindowExists(window.handle)) {
+        bindings.delete(chord);
+    }
+}
+if (bindings.size > 0) {
+    printBindings();
+}

package/dist/koffi/chord-listener.js

@@ -0,0 +1,94 @@
+import { HC_ACTION, PM_REMOVE, VK_ESCAPE, WH_KEYBOARD_LL, WM_KEYDOWN, WM_SYSKEYDOWN, buildCurrentChord, normalizeChord, } from "./chord-utils.js";
+import { registerKeyboardHookCallback, CallNextHookEx, decodeKeyboardHookLParam, GetModuleHandleW, SetWindowsHookExW, UnhookWindowsHookEx, unregisterCallback, PeekMessageW, TranslateMessage, DispatchMessageW, } from "./koffi-utils.js";
+export function startListening(options) {
+    const activationNormalized = options.activationChord
+        ? normalizeChord(options.activationChord)
+        : null;
+    if (options.activationChord && !activationNormalized) {
+        console.error(`[error] Invalid activation chord: ${options.activationChord}`);
+        process.exit(1);
+    }
+    let keyboardHook = null;
+    let keyboardHookProcPtr = null;
+    let messagePump;
+    let isShuttingDown = false;
+    const callback = (nCode, wParam, lParam) => {
+        const passThrough = () => BigInt(Number(CallNextHookEx(keyboardHook, nCode, wParam, lParam)));
+        try {
+            if (nCode !== HC_ACTION) {
+                return passThrough();
+            }
+            const message = Number(wParam);
+            if (message !== WM_KEYDOWN && message !== WM_SYSKEYDOWN) {
+                return passThrough();
+            }
+            const kb = decodeKeyboardHookLParam(lParam);
+            const vkCode = Number(kb.vkCode);
+            let shouldStopPropagation = false;
+            if (vkCode === VK_ESCAPE) {
+                options.onEscape?.(() => {
+                    shouldStopPropagation = true;
+                });
+                if (shouldStopPropagation) {
+                    return 1n;
+                }
+            }
+            const combo = buildCurrentChord(vkCode);
+            if (!combo) {
+                return passThrough();
+            }
+            if (activationNormalized && combo === activationNormalized) {
+                options.onActivation?.(() => {
+                    shouldStopPropagation = true;
+                });
+            }
+            options.onChord(combo, () => {
+                shouldStopPropagation = true;
+            });
+            if (shouldStopPropagation) {
+                return 1n;
+            }
+            return passThrough();
+        }
+        catch (error) {
+            console.error("[error] Keyboard hook callback failed:", error);
+            return passThrough();
+        }
+    };
+    keyboardHookProcPtr = registerKeyboardHookCallback(callback);
+    const moduleHandle = GetModuleHandleW(null);
+    keyboardHook = SetWindowsHookExW(WH_KEYBOARD_LL, keyboardHookProcPtr, moduleHandle, 0);
+    if (!keyboardHook) {
+        console.error("[error] SetWindowsHookExW failed.");
+        process.exit(1);
+    }
+    function shutdown() {
+        if (isShuttingDown) {
+            return;
+        }
+        isShuttingDown = true;
+        console.log("\n[qdesk] Shutting down...");
+        if (messagePump) {
+            clearInterval(messagePump);
+            messagePump = undefined;
+        }
+        if (keyboardHook) {
+            UnhookWindowsHookEx(keyboardHook);
+            keyboardHook = null;
+        }
+        if (keyboardHookProcPtr) {
+            unregisterCallback(keyboardHookProcPtr);
+            keyboardHookProcPtr = null;
+        }
+        process.exit(0);
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    const msg = {};
+    messagePump = setInterval(() => {
+        while (Number(PeekMessageW(msg, null, 0, 0, PM_REMOVE)) !== 0) {
+            TranslateMessage(msg);
+            DispatchMessageW(msg);
+        }
+    }, 8);
+}

package/dist/koffi/chord-utils.js

@@ -0,0 +1,148 @@
+import { GetAsyncKeyState } from "./koffi-utils.js";
+const MOD_ALT = 0x0001;
+const MOD_CONTROL = 0x0002;
+const MOD_SHIFT = 0x0004;
+const MOD_WIN = 0x0008;
+const VK_SHIFT = 0x10;
+const VK_CONTROL = 0x11;
+const VK_MENU = 0x12;
+export const VK_ESCAPE = 0x1b;
+const VK_LWIN = 0x5b;
+const VK_RWIN = 0x5c;
+export const HC_ACTION = 0;
+export const WH_KEYBOARD_LL = 13;
+export const WM_KEYDOWN = 0x0100;
+export const WM_SYSKEYDOWN = 0x0104;
+export const PM_REMOVE = 0x0001;
+export function normalizeChord(chord) {
+    chord = chord.trim().toLowerCase();
+    const parts = chord
+        .split("+")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    if (parts.length < 2) {
+        return null;
+    }
+    const key = parts[parts.length - 1];
+    if (!/^[0-9a-z]$/.test(key) && !/^f([1-9]|1[0-9]|2[0-4])$/.test(key)) {
+        return null;
+    }
+    const modifiers = new Set(parts.slice(0, -1));
+    for (const mod of modifiers) {
+        if (!["ctrl", "control", "alt", "shift", "win", "meta"].includes(mod)) {
+            return null;
+        }
+    }
+    const normalizedMods = [];
+    if (modifiers.has("ctrl") || modifiers.has("control")) {
+        normalizedMods.push("ctrl");
+    }
+    if (modifiers.has("alt")) {
+        normalizedMods.push("alt");
+    }
+    if (modifiers.has("shift")) {
+        normalizedMods.push("shift");
+    }
+    if (modifiers.has("win") || modifiers.has("meta")) {
+        normalizedMods.push("win");
+    }
+    if (normalizedMods.length === 0) {
+        return null;
+    }
+    return `${normalizedMods.join("+")}+${key}`;
+}
+export function parseHotkeyCombo(combo) {
+    const parts = combo
+        .split("+")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    if (parts.length < 2) {
+        return null;
+    }
+    const key = parts[parts.length - 1];
+    const modifiers = parts.slice(0, -1);
+    let modMask = 0;
+    const normalizedModifiers = [];
+    for (const mod of modifiers) {
+        if (mod === "alt") {
+            modMask |= MOD_ALT;
+            normalizedModifiers.push("alt");
+        }
+        else if (mod === "ctrl" || mod === "control") {
+            modMask |= MOD_CONTROL;
+            normalizedModifiers.push("ctrl");
+        }
+        else if (mod === "shift") {
+            modMask |= MOD_SHIFT;
+            normalizedModifiers.push("shift");
+        }
+        else if (mod === "win" || mod === "meta") {
+            modMask |= MOD_WIN;
+            normalizedModifiers.push("win");
+        }
+        else {
+            return null;
+        }
+    }
+    let vk = -1;
+    if (/^[0-9]$/.test(key)) {
+        vk = key.charCodeAt(0);
+    }
+    else if (/^[a-z]$/.test(key)) {
+        vk = key.toUpperCase().charCodeAt(0);
+    }
+    else {
+        const functionMatch = /^f([1-9]|1[0-9]|2[0-4])$/.exec(key);
+        if (functionMatch) {
+            const fn = Number(functionMatch[1]);
+            vk = 0x70 + (fn - 1);
+        }
+    }
+    if (vk < 0 || modMask === 0) {
+        return null;
+    }
+    const canonicalModifiers = ["ctrl", "alt", "shift", "win"].filter((mod) => normalizedModifiers.includes(mod));
+    return {
+        modifiers: modMask,
+        vk,
+        normalized: `${canonicalModifiers.join("+")}+${key}`,
+    };
+}
+function isPressed(vk) {
+    return (Number(GetAsyncKeyState(vk)) & 0x8000) !== 0;
+}
+function vkToKeyToken(vkCode) {
+    if (vkCode >= 0x30 && vkCode <= 0x39) {
+        return String.fromCharCode(vkCode);
+    }
+    if (vkCode >= 0x41 && vkCode <= 0x5a) {
+        return String.fromCharCode(vkCode).toLowerCase();
+    }
+    if (vkCode >= 0x70 && vkCode <= 0x87) {
+        return `f${vkCode - 0x6f}`;
+    }
+    return null;
+}
+export function buildCurrentChord(vkCode) {
+    const key = vkToKeyToken(vkCode);
+    if (!key) {
+        return null;
+    }
+    const parts = [];
+    if (isPressed(VK_CONTROL)) {
+        parts.push("ctrl");
+    }
+    if (isPressed(VK_MENU)) {
+        parts.push("alt");
+    }
+    if (isPressed(VK_SHIFT)) {
+        parts.push("shift");
+    }
+    if (isPressed(VK_LWIN) || isPressed(VK_RWIN)) {
+        parts.push("win");
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return `${parts.join("+")}+${key}`;
+}

package/dist/{koffi-utils.js → koffi/koffi-utils.js}

@@ -22,14 +22,24 @@ const KBDLLHOOKSTRUCT = koffi.struct("KBDLLHOOKSTRUCT", {
     dwExtraInfo: "uint64",
 });
 const KeyboardHookProc = koffi.proto("int64 KeyboardHookProc(int nCode, uint64 wParam, void *lParam)");
-const user32 = koffi.load("user32.dll");
-const kernel32 = koffi.load("kernel32.dll");
+export const user32 = koffi.load("user32.dll");
+export const kernel32 = koffi.load("kernel32.dll");
+export const gdi32 = koffi.load("gdi32.dll");
+export const magnification = (() => {
+    try {
+        return koffi.load("Magnification.dll");
+    }
+    catch {
+        return null;
+    }
+})();
 export const GetForegroundWindow = user32.func("GetForegroundWindow", HWND, []);
 export const SetForegroundWindow = user32.func("SetForegroundWindow", "int", [
     HWND,
 ]);
 export const IsWindow = user32.func("IsWindow", "int", [HWND]);
 export const IsIconic = user32.func("IsIconic", "int", [HWND]);
+export const IsZoomed = user32.func("IsZoomed", "int", [HWND]);
 export const ShowWindow = user32.func("ShowWindow", "int", [HWND, "int"]);
 export const BringWindowToTop = user32.func("BringWindowToTop", "int", [HWND]);
 export const SetActiveWindow = user32.func("SetActiveWindow", HWND, [HWND]);

package/dist/{screen-hue.js → koffi/screen-hue.js}

@@ -1,15 +1,6 @@
 import koffi from "koffi";
-import { HWND } from "./koffi-utils.js";
+import { gdi32, HWND, magnification, user32 } from "./koffi-utils.js";
 const HDC = koffi.pointer("HDC", koffi.opaque());
-const user32 = koffi.load("user32.dll");
-const gdi32 = koffi.load("gdi32.dll");
-let magnification = null;
-try {
-    magnification = koffi.load("Magnification.dll");
-}
-catch {
-    magnification = null;
-}
 const GetDC = user32.func("GetDC", HDC, [HWND]);
 const ReleaseDC = user32.func("ReleaseDC", "int", [HWND, HDC]);
 const SetDeviceGammaRamp = gdi32.func("SetDeviceGammaRamp", "int", [

package/dist/{window-utils.js → koffi/window-utils.js}

@@ -1,7 +1,8 @@
 import { Buffer } from "node:buffer";
-import { AttachThreadInput, BringWindowToTop, GetForegroundWindow, GetCurrentThreadId, GetWindowThreadProcessId, GetWindowTextW, IsIconic, IsWindow, SetActiveWindow, SetForegroundWindow, ShowWindow, } from "./koffi-utils.js";
+import { AttachThreadInput, BringWindowToTop, GetForegroundWindow, GetCurrentThreadId, GetWindowThreadProcessId, GetWindowTextW, IsIconic, IsZoomed, IsWindow, SetActiveWindow, SetForegroundWindow, ShowWindow, } from "./koffi-utils.js";
 const SW_RESTORE = 9;
 const SW_SHOW = 5;
+const SW_SHOWMAXIMIZED = 3;
 function getWindowTitle(hwnd) {
     const buf = Buffer.alloc(512);
     const len = Number(GetWindowTextW(hwnd, buf, 256));
@@ -21,12 +22,18 @@ export function activateWindowByHandle(handle) {
     if (!Number(IsWindow(handle))) {
         return "missing";
     }
-    if (Number(IsIconic(handle))) {
-        ShowWindow(handle, SW_RESTORE);
-    }
-    else {
+    const showTargetWindow = () => {
+        if (Number(IsIconic(handle))) {
+            ShowWindow(handle, SW_RESTORE);
+            return;
+        }
+        if (Number(IsZoomed(handle))) {
+            ShowWindow(handle, SW_SHOWMAXIMIZED);
+            return;
+        }
         ShowWindow(handle, SW_SHOW);
-    }
+    };
+    showTargetWindow();
     // Fast path for windows that can be foregrounded immediately.
     if (Number(SetForegroundWindow(handle)) !== 0) {
         return "activated";
@@ -51,7 +58,7 @@ export function activateWindowByHandle(handle) {
         tryAttach(targetThreadId);
         BringWindowToTop(handle);
         SetActiveWindow(handle);
-        ShowWindow(handle, SW_SHOW);
+        showTargetWindow();
         if (Number(SetForegroundWindow(handle)) !== 0) {
             return "activated";
         }
@@ -63,3 +70,6 @@ export function activateWindowByHandle(handle) {
     }
     return "failed";
 }
+export function checkIfWindowExists(handle) {
+    return Boolean(IsWindow(handle));
+}

package/dist/log/log.js

@@ -0,0 +1,13 @@
+export function logSwitch({ chord, name, type, }) {
+    const status = type === "success" ? "✅" : type === "failed" ? "⚠️" : "❓";
+    console.log(`[switch ${chord}] ${status} "${name}"`);
+}
+export function logInfo(message) {
+    console.log(`[info] ${message}`);
+}
+export function logError(message) {
+    console.error(`[error] ${message}`);
+}
+export function logWarn(message) {
+    console.warn(`[warn] ${message}`);
+}

package/dist/process/cli.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "fs";
+import { normalizeChord } from "../koffi/chord-utils.js";
+const DEFAULT_ADD_CHORD = "win+ctrl+a";
+const DEFAULT_DROP_CHORD = "win+ctrl+d";
+export function getCliArgStuff() {
+    if (hasCliFlag("--version") || hasCliFlag("-v")) {
+        console.log(getPackageVersion());
+        process.exit(0);
+    }
+    setTerminalTitle("qdesk");
+    const ADD_CHORD = normalizeChord(getCliArgValue("-a") ?? DEFAULT_ADD_CHORD);
+    const DROP_CHORD = normalizeChord(getCliArgValue("-d") ?? DEFAULT_DROP_CHORD);
+    return { ADD_CHORD, DROP_CHORD };
+}
+function hasCliFlag(flag) {
+    return process.argv.slice(2).includes(flag);
+}
+function getPackageVersion() {
+    try {
+        const packageJson = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+        const parsed = JSON.parse(packageJson);
+        return parsed.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function setTerminalTitle(title) {
+    process.title = title;
+    if (process.stdout.isTTY) {
+        process.stdout.write(`\u001b]0;${title}\u0007`);
+    }
+}
+function getCliArgValue(flag) {
+    const args = process.argv.slice(2);
+    const exact = args.find((arg) => arg.startsWith(`${flag}=`));
+    if (exact) {
+        return exact.slice(flag.length + 1);
+    }
+    const idx = args.indexOf(flag);
+    if (idx >= 0 && idx + 1 < args.length) {
+        return args[idx + 1];
+    }
+    return undefined;
+}

package/dist/process/get-process-creation-time.js

@@ -0,0 +1,45 @@
+import koffi from "koffi";
+import { kernel32 } from "../koffi/koffi-utils.js";
+const HANDLE = koffi.pointer("HANDLE", koffi.opaque());
+const OpenProcess = kernel32.func("OpenProcess", HANDLE, [
+    "uint32",
+    "int",
+    "uint32",
+]);
+const GetProcessTimes = kernel32.func("GetProcessTimes", "int", [
+    HANDLE,
+    "void *",
+    "void *",
+    "void *",
+    "void *",
+]);
+const CloseHandle = kernel32.func("CloseHandle", "int", [HANDLE]);
+const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
+function readFileTime(buffer) {
+    const low = BigInt(buffer.readUInt32LE(0));
+    const high = BigInt(buffer.readUInt32LE(4));
+    return ((high << 32n) | low).toString();
+}
+export function getProcessCreationTime(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    const processHandle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
+    if (!processHandle) {
+        return null;
+    }
+    const creationTime = Buffer.alloc(8);
+    const exitTime = Buffer.alloc(8);
+    const kernelTime = Buffer.alloc(8);
+    const userTime = Buffer.alloc(8);
+    try {
+        const ok = Number(GetProcessTimes(processHandle, creationTime, exitTime, kernelTime, userTime));
+        if (!ok) {
+            return null;
+        }
+        return readFileTime(creationTime);
+    }
+    finally {
+        CloseHandle(processHandle);
+    }
+}

package/dist/process/process-deduplication.js

@@ -0,0 +1,26 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getProcessCreationTime } from "./get-process-creation-time.js";
+const LOCK_FILE = path.join(os.tmpdir(), "qdesk.lock");
+export function isAlreadyRunning() {
+    try {
+        const lockInfo = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8").trim());
+        process.kill(lockInfo.pid, 0);
+        return getProcessCreationTime(lockInfo.pid) === lockInfo.creationTime;
+    }
+    catch {
+        // stale lock, fall through
+    }
+    fs.writeFileSync(LOCK_FILE, JSON.stringify({
+        pid: process.pid,
+        creationTime: getProcessCreationTime(process.pid),
+    }));
+    return false;
+}
+export function ensureSingleProcess() {
+    if (isAlreadyRunning()) {
+        console.error("Another instance is already running. Exiting.");
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qdesk",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
   "repository": {
     "type": "git",

package/dist/chord-utils.js

@@ -1,244 +0,0 @@
-import { CallNextHookEx, decodeKeyboardHookLParam, DispatchMessageW, GetAsyncKeyState, GetModuleHandleW, PeekMessageW, registerKeyboardHookCallback, SetWindowsHookExW, TranslateMessage, UnhookWindowsHookEx, unregisterCallback, } from "./koffi-utils.js";
-const process = globalThis.process;
-const MOD_ALT = 0x0001;
-const MOD_CONTROL = 0x0002;
-const MOD_SHIFT = 0x0004;
-const MOD_WIN = 0x0008;
-const VK_SHIFT = 0x10;
-const VK_CONTROL = 0x11;
-const VK_MENU = 0x12;
-const VK_ESCAPE = 0x1b;
-const VK_LWIN = 0x5b;
-const VK_RWIN = 0x5c;
-const HC_ACTION = 0;
-const WH_KEYBOARD_LL = 13;
-const WM_KEYDOWN = 0x0100;
-const WM_SYSKEYDOWN = 0x0104;
-const PM_REMOVE = 0x0001;
-export function normalizeChord(chord) {
-    const parts = chord
-        .split("+")
-        .map((part) => part.trim().toLowerCase())
-        .filter(Boolean);
-    if (parts.length < 2) {
-        return null;
-    }
-    const key = parts[parts.length - 1];
-    if (!/^[0-9a-z]$/.test(key) && !/^f([1-9]|1[0-9]|2[0-4])$/.test(key)) {
-        return null;
-    }
-    const modifiers = new Set(parts.slice(0, -1));
-    for (const mod of modifiers) {
-        if (!["ctrl", "control", "alt", "shift", "win", "meta"].includes(mod)) {
-            return null;
-        }
-    }
-    const normalizedMods = [];
-    if (modifiers.has("ctrl") || modifiers.has("control")) {
-        normalizedMods.push("ctrl");
-    }
-    if (modifiers.has("alt")) {
-        normalizedMods.push("alt");
-    }
-    if (modifiers.has("shift")) {
-        normalizedMods.push("shift");
-    }
-    if (modifiers.has("win") || modifiers.has("meta")) {
-        normalizedMods.push("win");
-    }
-    if (normalizedMods.length === 0) {
-        return null;
-    }
-    return `${normalizedMods.join("+")}+${key}`;
-}
-function parseHotkeyCombo(combo) {
-    const parts = combo
-        .split("+")
-        .map((part) => part.trim().toLowerCase())
-        .filter(Boolean);
-    if (parts.length < 2) {
-        return null;
-    }
-    const key = parts[parts.length - 1];
-    const modifiers = parts.slice(0, -1);
-    let modMask = 0;
-    const normalizedModifiers = [];
-    for (const mod of modifiers) {
-        if (mod === "alt") {
-            modMask |= MOD_ALT;
-            normalizedModifiers.push("alt");
-        }
-        else if (mod === "ctrl" || mod === "control") {
-            modMask |= MOD_CONTROL;
-            normalizedModifiers.push("ctrl");
-        }
-        else if (mod === "shift") {
-            modMask |= MOD_SHIFT;
-            normalizedModifiers.push("shift");
-        }
-        else if (mod === "win" || mod === "meta") {
-            modMask |= MOD_WIN;
-            normalizedModifiers.push("win");
-        }
-        else {
-            return null;
-        }
-    }
-    let vk = -1;
-    if (/^[0-9]$/.test(key)) {
-        vk = key.charCodeAt(0);
-    }
-    else if (/^[a-z]$/.test(key)) {
-        vk = key.toUpperCase().charCodeAt(0);
-    }
-    else {
-        const functionMatch = /^f([1-9]|1[0-9]|2[0-4])$/.exec(key);
-        if (functionMatch) {
-            const fn = Number(functionMatch[1]);
-            vk = 0x70 + (fn - 1);
-        }
-    }
-    if (vk < 0 || modMask === 0) {
-        return null;
-    }
-    const canonicalModifiers = ["ctrl", "alt", "shift", "win"].filter((mod) => normalizedModifiers.includes(mod));
-    return {
-        modifiers: modMask,
-        vk,
-        normalized: `${canonicalModifiers.join("+")}+${key}`,
-    };
-}
-function isPressed(vk) {
-    return (Number(GetAsyncKeyState(vk)) & 0x8000) !== 0;
-}
-function vkToKeyToken(vkCode) {
-    if (vkCode >= 0x30 && vkCode <= 0x39) {
-        return String.fromCharCode(vkCode);
-    }
-    if (vkCode >= 0x41 && vkCode <= 0x5a) {
-        return String.fromCharCode(vkCode).toLowerCase();
-    }
-    if (vkCode >= 0x70 && vkCode <= 0x87) {
-        return `f${vkCode - 0x6f}`;
-    }
-    return null;
-}
-function buildCurrentChord(vkCode) {
-    const key = vkToKeyToken(vkCode);
-    if (!key) {
-        return null;
-    }
-    const parts = [];
-    if (isPressed(VK_CONTROL)) {
-        parts.push("ctrl");
-    }
-    if (isPressed(VK_MENU)) {
-        parts.push("alt");
-    }
-    if (isPressed(VK_SHIFT)) {
-        parts.push("shift");
-    }
-    if (isPressed(VK_LWIN) || isPressed(VK_RWIN)) {
-        parts.push("win");
-    }
-    if (parts.length === 0) {
-        return null;
-    }
-    return `${parts.join("+")}+${key}`;
-}
-export function startListening(options) {
-    const activationNormalized = options.activationChord
-        ? normalizeChord(options.activationChord)
-        : null;
-    if (options.activationChord && !activationNormalized) {
-        console.error(`[error] Invalid activation chord: ${options.activationChord}`);
-        process.exit(1);
-    }
-    let keyboardHook = null;
-    let keyboardHookProcPtr = null;
-    let messagePump;
-    let isShuttingDown = false;
-    const callback = (nCode, wParam, lParam) => {
-        const passThrough = () => BigInt(Number(CallNextHookEx(keyboardHook, nCode, wParam, lParam)));
-        try {
-            if (nCode !== HC_ACTION) {
-                return passThrough();
-            }
-            const message = Number(wParam);
-            if (message !== WM_KEYDOWN && message !== WM_SYSKEYDOWN) {
-                return passThrough();
-            }
-            const kb = decodeKeyboardHookLParam(lParam);
-            const vkCode = Number(kb.vkCode);
-            let shouldStopPropagation = false;
-            if (vkCode === VK_ESCAPE) {
-                options.onEscape?.(() => {
-                    shouldStopPropagation = true;
-                });
-                if (shouldStopPropagation) {
-                    return 1n;
-                }
-            }
-            const combo = buildCurrentChord(vkCode);
-            if (!combo) {
-                return passThrough();
-            }
-            if (activationNormalized && combo === activationNormalized) {
-                options.onActivation?.(() => {
-                    shouldStopPropagation = true;
-                });
-            }
-            options.onChord(combo, () => {
-                shouldStopPropagation = true;
-            });
-            if (shouldStopPropagation) {
-                return 1n;
-            }
-            return passThrough();
-        }
-        catch (error) {
-            console.error("[error] Keyboard hook callback failed:", error);
-            return passThrough();
-        }
-    };
-    keyboardHookProcPtr = registerKeyboardHookCallback(callback);
-    const moduleHandle = GetModuleHandleW(null);
-    keyboardHook = SetWindowsHookExW(WH_KEYBOARD_LL, keyboardHookProcPtr, moduleHandle, 0);
-    if (!keyboardHook) {
-        console.error("[error] SetWindowsHookExW failed.");
-        process.exit(1);
-    }
-    function shutdown() {
-        if (isShuttingDown) {
-            return;
-        }
-        isShuttingDown = true;
-        console.log("\n[qdesk] Shutting down...");
-        if (messagePump) {
-            clearInterval(messagePump);
-            messagePump = undefined;
-        }
-        if (keyboardHook) {
-            UnhookWindowsHookEx(keyboardHook);
-            keyboardHook = null;
-        }
-        if (keyboardHookProcPtr) {
-            unregisterCallback(keyboardHookProcPtr);
-            keyboardHookProcPtr = null;
-        }
-        process.exit(0);
-    }
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    return {
-        runMessageLoop: () => {
-            const msg = {};
-            messagePump = setInterval(() => {
-                while (Number(PeekMessageW(msg, null, 0, 0, PM_REMOVE)) !== 0) {
-                    TranslateMessage(msg);
-                    DispatchMessageW(msg);
-                }
-            }, 8);
-        },
-    };
-}