qdesk 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# qdesk
+
+Global keyboard chord switcher for Windows.
+
+qdesk lets you:
+
+- Arm an add mode, then press any chord to bind the current foreground window.
+- Arm a remove mode, then press a chord to delete that binding.
+- Jump to a bound window by pressing its chord.
+
+It uses native Win32 APIs through Koffi.
+
+## Platform
+
+- Windows only
+- Node.js 18+ recommended
+
+## Run With npx
+
+Run directly without installing globally:
+
+```powershell
+npx qdesk
+```
+
+Override control chords at startup:
+
+```powershell
+npx qdesk -a ctrl+shift+r -d ctrl+shift+d
+```
+
+Startup flags:
+
+- `-a <combo>`: add/bind mode trigger
+- `-d <combo>`: drop mode trigger
+
+Defaults:
+
+- add chord: `ctrl+win+a`
+- drop chord: `ctrl+win+d`
+
+## How It Works
+
+1. Press the `add` chord.
+2. qdesk enters recording mode (red screen hue indicates recording).
+3. Press the chord you want to bind.
+4. Press that bound chord later to activate its window.
+
+Remove flow:
+
+1. Press the 'drop' chord.
+2. qdesk enters remove mode (green hue).
+3. Press the chord to delete.
+
+## Install Locally (Dev)
+
+```powershell
+pnpm install
+pnpm build
+pnpm start
+```
+
+Run directly from TypeScript source:
+
+```powershell
+pnpm dev
+```
+
+## Package Scripts
+
+- `pnpm dev` - run from TypeScript source
+- `pnpm build` - clean and compile to `dist`
+- `pnpm start` - run compiled CLI
+- `pnpm prepack` - build before packing/publishing
+
+## Publish/Test Package
+
+Create a tarball:
+
+```powershell
+pnpm pack
+```
+
+Test tarball locally:
+
+```powershell
+npx --yes .\qdesk-<version>.tgz
+```
+
+## Notes
+
+- Some display/driver combinations may limit screen hue APIs.
+- Window activation can be restricted by Windows focus rules for certain apps.
+- Use unique add/drop chords to avoid mode conflicts.

package/dist/chord-utils.js

@@ -0,0 +1,228 @@
+import { CallNextHookEx, decodeKeyboardHookLParam, DispatchMessageW, GetAsyncKeyState, GetMessageW, GetModuleHandleW, registerKeyboardHookCallback, SetWindowsHookExW, TranslateMessage, UnhookWindowsHookEx, unregisterCallback, } 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;
+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;
+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;
+    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 combo = buildCurrentChord(Number(kb.vkCode));
+            if (!combo) {
+                return passThrough();
+            }
+            let shouldStopPropagation = false;
+            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() {
+        console.log("\n[qdesk] Shutting down...");
+        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 = {};
+            while (true) {
+                const ret = Number(GetMessageW(msg, null, 0, 0));
+                if (ret === 0) {
+                    break;
+                }
+                if (ret === -1) {
+                    console.error("[error] GetMessageW returned -1");
+                    break;
+                }
+                TranslateMessage(msg);
+                DispatchMessageW(msg);
+            }
+        },
+    };
+}

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+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 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);
+if (ADD_CHORD === DROP_CHORD) {
+    console.warn(`[warn] 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)");
+let removalReturnWindow;
+const listener = startListening({
+    onChord: (chord, stopPropagating) => {
+        if (activeRecording) {
+            if ([ADD_CHORD, DROP_CHORD].includes(chord)) {
+                console.warn(`[warn] 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();
+            return stopPropagating();
+        }
+        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}`);
+            }
+            printBindings();
+            return stopPropagating();
+        }
+        if (chord === ADD_CHORD) {
+            awaitingChordRemoval = false;
+            setScreenHue("off");
+            activeRecording = getActiveWindowHandleAndName();
+            if (!activeRecording) {
+                console.warn("[warn] No foreground window found to bind.");
+            }
+            else {
+                console.log(`[add] Armed for "${activeRecording.name}". Waiting for next chord...`);
+                setScreenHue("record");
+            }
+            return stopPropagating();
+        }
+        if (chord === DROP_CHORD) {
+            if (activeRecording) {
+                activeRecording = undefined;
+                setScreenHue("off");
+            }
+            awaitingChordRemoval = true;
+            if (toolWindowAtStartup) {
+                activateWindowByHandle(toolWindowAtStartup.handle);
+            }
+            console.log("[drop] Armed. Press the chord you want to remove.");
+            printBindings();
+            setScreenHue("remove");
+            return stopPropagating();
+        }
+        const binding = bindings.get(chord);
+        if (binding) {
+            const result = activateWindowByHandle(binding.handle);
+            if (result === "missing") {
+                console.error(`[switch ${chord}] Window "${binding.name}" no longer exists, clearing binding.`);
+                bindings.delete(chord);
+            }
+            else if (result === "activated") {
+                console.log(`[binding ${chord}] Switched to "${binding.name}"`);
+            }
+            else {
+                console.warn(`[switch ${chord}] Activation failed for "${binding.name}"`);
+            }
+            return stopPropagating();
+        }
+    },
+});
+function printBindings() {
+    console.log("\n[qdesk] Current bindings:");
+    if (bindings.size === 0) {
+        console.log("  (none)");
+    }
+    else {
+        for (const [chord, window] of bindings) {
+            console.log(`  ${chord} -> "${window.name}"`);
+        }
+    }
+    console.log("");
+}
+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();

package/dist/koffi-utils.js

@@ -0,0 +1,89 @@
+import koffi from "koffi";
+export const HWND = koffi.pointer("HWND", koffi.opaque());
+const HHOOK = koffi.pointer("HHOOK", koffi.opaque());
+const HINSTANCE = koffi.pointer("HINSTANCE", koffi.opaque());
+const UINT = "uint32";
+const WPARAM = "uint64";
+const LPARAM = "int64";
+const MSG = koffi.struct("MSG", {
+    hwnd: HWND,
+    message: UINT,
+    wParam: WPARAM,
+    lParam: LPARAM,
+    time: "uint32",
+    ptX: "int32",
+    ptY: "int32",
+});
+const KBDLLHOOKSTRUCT = koffi.struct("KBDLLHOOKSTRUCT", {
+    vkCode: "uint32",
+    scanCode: "uint32",
+    flags: "uint32",
+    time: "uint32",
+    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 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 ShowWindow = user32.func("ShowWindow", "int", [HWND, "int"]);
+export const BringWindowToTop = user32.func("BringWindowToTop", "int", [HWND]);
+export const SetActiveWindow = user32.func("SetActiveWindow", HWND, [HWND]);
+export const AttachThreadInput = user32.func("AttachThreadInput", "int", [
+    "uint32",
+    "uint32",
+    "int",
+]);
+export const GetWindowThreadProcessId = user32.func("GetWindowThreadProcessId", "uint32", [HWND, "void *"]);
+export const GetWindowTextW = user32.func("GetWindowTextW", "int", [
+    HWND,
+    koffi.out("char16 *"),
+    "int",
+]);
+export const GetAsyncKeyState = user32.func("GetAsyncKeyState", "int16", [
+    "int",
+]);
+export const GetMessageW = user32.func("GetMessageW", "int", [
+    koffi.out(koffi.pointer(MSG)),
+    HWND,
+    UINT,
+    UINT,
+]);
+export const TranslateMessage = user32.func("TranslateMessage", "int", [
+    koffi.pointer(MSG),
+]);
+export const DispatchMessageW = user32.func("DispatchMessageW", LPARAM, [
+    koffi.pointer(MSG),
+]);
+export const SetWindowsHookExW = user32.func("SetWindowsHookExW", HHOOK, [
+    "int",
+    koffi.pointer(KeyboardHookProc),
+    HINSTANCE,
+    "uint32",
+]);
+export const CallNextHookEx = user32.func("CallNextHookEx", "int64", [
+    HHOOK,
+    "int",
+    "uint64",
+    "void *",
+]);
+export const UnhookWindowsHookEx = user32.func("UnhookWindowsHookEx", "int", [
+    HHOOK,
+]);
+export const GetModuleHandleW = kernel32.func("GetModuleHandleW", HINSTANCE, [
+    "char16 *",
+]);
+export const GetCurrentThreadId = kernel32.func("GetCurrentThreadId", "uint32", []);
+export function decodeKeyboardHookLParam(lParam) {
+    return koffi.decode(lParam, KBDLLHOOKSTRUCT);
+}
+export function registerKeyboardHookCallback(callback) {
+    return koffi.register(callback, koffi.pointer(KeyboardHookProc));
+}
+export function unregisterCallback(cb) {
+    koffi.unregister(cb);
+}

package/dist/screen-hue.js

@@ -0,0 +1,162 @@
+import koffi from "koffi";
+import { HWND } 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", [
+    HDC,
+    "void *",
+]);
+const MagInitialize = magnification
+    ? magnification.func("MagInitialize", "int", [])
+    : null;
+const MagSetFullscreenColorEffect = magnification
+    ? magnification.func("MagSetFullscreenColorEffect", "int", ["void *"])
+    : null;
+let hasWarnedGammaFailure = false;
+let hasWarnedMagFailure = false;
+let magInitialized = false;
+let activeHueBackend = "none";
+function clampScale(value) {
+    return Math.max(0.0, Math.min(1.0, value));
+}
+function buildGammaRamp(redScale, greenScale, blueScale) {
+    // 3 channels * 256 entries * 2 bytes per uint16
+    const ramp = Buffer.alloc(3 * 256 * 2);
+    const red = clampScale(redScale);
+    const green = clampScale(greenScale);
+    const blue = clampScale(blueScale);
+    for (let i = 0; i < 256; i++) {
+        const base = i * 257; // map 0..255 to 0..65535
+        const redValue = Math.max(0, Math.min(65535, Math.round(base * red)));
+        const greenValue = Math.max(0, Math.min(65535, Math.round(base * green)));
+        const blueValue = Math.max(0, Math.min(65535, Math.round(base * blue)));
+        ramp.writeUInt16LE(redValue, i * 2);
+        ramp.writeUInt16LE(greenValue, (256 + i) * 2);
+        ramp.writeUInt16LE(blueValue, (512 + i) * 2);
+    }
+    return ramp;
+}
+function buildColorEffectMatrix(mode) {
+    // MAGCOLOREFFECT is a 5x5 float matrix.
+    const matrix = Buffer.alloc(25 * 4);
+    const redScale = mode === "record" ? 1.0 : mode === "remove" ? 0.35 : 1.0;
+    const greenScale = mode === "record" ? 0.3 : mode === "remove" ? 1.0 : 1.0;
+    const blueScale = mode === "record" ? 0.18 : mode === "remove" ? 0.35 : 1.0;
+    const values = [
+        redScale,
+        0,
+        0,
+        0,
+        0,
+        0,
+        greenScale,
+        0,
+        0,
+        0,
+        0,
+        0,
+        blueScale,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+    ];
+    for (let i = 0; i < values.length; i++) {
+        matrix.writeFloatLE(values[i], i * 4);
+    }
+    return matrix;
+}
+function tryApplyMagnifierHue(mode) {
+    if (!MagInitialize || !MagSetFullscreenColorEffect) {
+        return false;
+    }
+    if (!magInitialized) {
+        const initOk = Number(MagInitialize());
+        if (!initOk) {
+            return false;
+        }
+        magInitialized = true;
+    }
+    const matrix = buildColorEffectMatrix(mode);
+    const ok = Number(MagSetFullscreenColorEffect(matrix));
+    return ok !== 0;
+}
+export function setScreenHue(mode) {
+    const screenDc = GetDC(null);
+    if (!screenDc) {
+        return;
+    }
+    try {
+        if (mode !== "off") {
+            // Try requested tint first, then a milder fallback accepted by more drivers.
+            const primaryRamp = mode === "record"
+                ? buildGammaRamp(1.0, 0.22, 0.35)
+                : buildGammaRamp(0.4, 1.0, 0.4);
+            let ok = Number(SetDeviceGammaRamp(screenDc, primaryRamp));
+            if (!ok) {
+                const fallbackRamp = mode === "record"
+                    ? buildGammaRamp(1.0, 0.58, 0.35)
+                    : buildGammaRamp(0.65, 1.0, 0.65);
+                ok = Number(SetDeviceGammaRamp(screenDc, fallbackRamp));
+            }
+            if (ok) {
+                activeHueBackend = "gamma";
+                return;
+            }
+            if (!hasWarnedGammaFailure) {
+                hasWarnedGammaFailure = true;
+                console.warn("[warn] Gamma ramp unsupported on this display/driver, trying Magnification fallback.");
+            }
+            if (tryApplyMagnifierHue(mode)) {
+                activeHueBackend = "magnifier";
+                return;
+            }
+            activeHueBackend = "none";
+            if (!hasWarnedMagFailure) {
+                hasWarnedMagFailure = true;
+                console.warn("[warn] Screen hue could not be applied on this system.");
+            }
+            return;
+        }
+        // Turning hue off: clear whichever backend might have been used.
+        let cleared = false;
+        if (activeHueBackend === "magnifier") {
+            cleared = tryApplyMagnifierHue("off");
+        }
+        const neutralRamp = buildGammaRamp(1.0, 1.0, 1.0);
+        const gammaCleared = Number(SetDeviceGammaRamp(screenDc, neutralRamp)) !== 0;
+        cleared = cleared || gammaCleared;
+        if (activeHueBackend !== "magnifier") {
+            // Safe no-op when magnifier was never used; necessary when it was.
+            cleared = tryApplyMagnifierHue("off") || cleared;
+        }
+        if (cleared) {
+            activeHueBackend = "none";
+        }
+        else if (!hasWarnedMagFailure) {
+            hasWarnedMagFailure = true;
+            console.warn("[warn] Screen hue could not be reset on this system.");
+        }
+    }
+    finally {
+        ReleaseDC(null, screenDc);
+    }
+}

package/dist/window-utils.js

@@ -0,0 +1,65 @@
+import { Buffer } from "node:buffer";
+import { AttachThreadInput, BringWindowToTop, GetForegroundWindow, GetCurrentThreadId, GetWindowThreadProcessId, GetWindowTextW, IsIconic, IsWindow, SetActiveWindow, SetForegroundWindow, ShowWindow, } from "./koffi-utils.js";
+const SW_RESTORE = 9;
+const SW_SHOW = 5;
+function getWindowTitle(hwnd) {
+    const buf = Buffer.alloc(512);
+    const len = Number(GetWindowTextW(hwnd, buf, 256));
+    return buf.slice(0, len * 2).toString("utf16le");
+}
+export function getActiveWindowHandleAndName() {
+    const hwnd = GetForegroundWindow();
+    if (!hwnd) {
+        return null;
+    }
+    return {
+        handle: hwnd,
+        name: getWindowTitle(hwnd),
+    };
+}
+export function activateWindowByHandle(handle) {
+    if (!Number(IsWindow(handle))) {
+        return "missing";
+    }
+    if (Number(IsIconic(handle))) {
+        ShowWindow(handle, SW_RESTORE);
+    }
+    else {
+        ShowWindow(handle, SW_SHOW);
+    }
+    // Fast path for windows that can be foregrounded immediately.
+    if (Number(SetForegroundWindow(handle)) !== 0) {
+        return "activated";
+    }
+    const currentThreadId = Number(GetCurrentThreadId());
+    const foreground = GetForegroundWindow();
+    const foregroundThreadId = foreground
+        ? Number(GetWindowThreadProcessId(foreground, null))
+        : 0;
+    const targetThreadId = Number(GetWindowThreadProcessId(handle, null));
+    const attachedThreadIds = [];
+    const tryAttach = (threadId) => {
+        if (threadId && threadId !== currentThreadId) {
+            const ok = Number(AttachThreadInput(currentThreadId, threadId, 1));
+            if (ok) {
+                attachedThreadIds.push(threadId);
+            }
+        }
+    };
+    try {
+        tryAttach(foregroundThreadId);
+        tryAttach(targetThreadId);
+        BringWindowToTop(handle);
+        SetActiveWindow(handle);
+        ShowWindow(handle, SW_SHOW);
+        if (Number(SetForegroundWindow(handle)) !== 0) {
+            return "activated";
+        }
+    }
+    finally {
+        for (const threadId of attachedThreadIds) {
+            AttachThreadInput(currentThreadId, threadId, 0);
+        }
+    }
+    return "failed";
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "qdesk",
+  "version": "1.0.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JakeBeaver/qdesk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JakeBeaver/qdesk/issues"
+  },
+  "homepage": "https://github.com/JakeBeaver/qdesk#readme",
+  "bin": {
+    "switcher": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "koffi": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.30",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "pnpm clean && tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  }
+}