@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/os/modules/windows/resident.js

@@ -0,0 +1,286 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import net from "node:net";
+import { dirname, join } from "node:path";
+import { processIdentity } from "./processes.js";
+import { readWindowsColorScheme } from "./color-scheme.js";
+import { stopWindowHost, warmWindowHelper } from "./hwnd.js";
+import { bindPipe, forward, isDesktopAction, launcherPidPath, launcherIdentityPath, launcherTokenPath, pipeTaken, reclaim, waitForForward, } from "./resident-pipe.js";
+import { startDesktopShell } from "./shell.js";
+import { restrictToOwner } from "./tools.js";
+const service = "dev.projector.Launcher";
+export { launcherPidPath, launcherTokenPath } from "./resident-pipe.js";
+export async function desktopPid(name) {
+    if (name !== service)
+        return;
+    try {
+        const pid = Number((await readFile(launcherPidPath(), "utf8")).trim());
+        // Windows processIdentity is async; a bare call always yields a truthy Promise.
+        if (!(await processIdentity(pid))) {
+            await rm(launcherPidPath(), { force: true });
+            return;
+        }
+        return pid;
+    }
+    catch {
+        return;
+    }
+}
+/** Owns the palette process. A second launch only forwards show, toggle, tray or quit. */
+export async function runResident(baseUrl, action, options) {
+    if (!isDesktopAction(action))
+        throw new Error("Неизвестная команда");
+    const requestId = randomUUID();
+    if (action === "quit") {
+        if ((await forward(action, options.dataDirectory, requestId)) ||
+            (await waitForForward(action, options.dataDirectory, 3, requestId))) {
+            console.log("READY");
+            return;
+        }
+        await reclaim(options.dataDirectory).catch(() => undefined);
+        console.log("READY");
+        return;
+    }
+    // Same idea as macOS: never start a second resident while the first still answers.
+    if (await waitForForward(action, options.dataDirectory, 8, requestId)) {
+        console.log("READY");
+        return;
+    }
+    // CIM can be slow. Resolve identity before binding so another launcher cannot
+    // mistake a pipe waiting for its token to be published for a hung resident.
+    const started = await processIdentity(process.pid);
+    const token = randomBytes(24).toString("hex");
+    const queued = [];
+    let live;
+    const attach = async () => bindPipe(token, async (requested) => {
+        if (live) {
+            await live(requested);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            queued.push(() => live(requested).then(resolve, reject));
+        });
+    });
+    let server;
+    try {
+        server = await attach();
+    }
+    catch (error) {
+        if (!pipeTaken(error))
+            throw error;
+        // Holder appeared between the forward loop and listen, or is hung with a stale token.
+        if (await waitForForward(action, options.dataDirectory, 5, requestId)) {
+            console.log("READY");
+            return;
+        }
+        await reclaim(options.dataDirectory);
+        try {
+            server = await attach();
+        }
+        catch (retryError) {
+            if (!pipeTaken(retryError) ||
+                !(await waitForForward(action, options.dataDirectory, 5, requestId)))
+                throw retryError;
+            console.log("READY");
+            return;
+        }
+    }
+    const pidPath = launcherPidPath(options.dataDirectory);
+    try {
+        await mkdir(dirname(pidPath), { recursive: true });
+        // Publish identity before GTK init so a racing second launch can forward instead of reclaiming.
+        await writeFile(pidPath, `${process.pid}\n`);
+        await writeFile(launcherIdentityPath(options.dataDirectory), JSON.stringify({ pid: process.pid, started }));
+        await writeFile(launcherTokenPath(options.dataDirectory), `${token}\n`, { mode: 0o600 });
+        await restrictToOwner(launcherTokenPath(options.dataDirectory)).catch(() => undefined);
+        await own(baseUrl, action, options, server, pidPath, (next) => {
+            live = next;
+            return queued.splice(0);
+        });
+    }
+    catch (error) {
+        server.close();
+        await rm(pidPath, { force: true });
+        await rm(launcherIdentityPath(options.dataDirectory), { force: true });
+        await rm(launcherTokenPath(options.dataDirectory), { force: true });
+        throw error;
+    }
+}
+async function own(baseUrl, action, options, server, pidPath, arm) {
+    let pulse;
+    let applyColorScheme = async () => { };
+    if (!options.webPalette) {
+        const { default: Gtk } = await import("gi:Gtk-4.0");
+        const { default: GLib } = await import("gi:GLib-2.0");
+        // Loaded before any window exists: only then is its surface wrapped as a Win32Surface.
+        await import("gi:GdkWin32-4.0").catch(() => undefined);
+        Gtk.init();
+        warmWindowHelper();
+        applyColorScheme = async () => {
+            try {
+                const resolved = await readWindowsColorScheme();
+                if (!resolved)
+                    return;
+                const settings = Gtk.Settings.getDefault();
+                if (!settings)
+                    return;
+                // GtkInterfaceColorScheme exists in newer GTK; older Windows bundles only follow the
+                // system theme themselves, so there is nothing to set.
+                const schemes = Gtk.InterfaceColorScheme;
+                if (!schemes)
+                    return;
+                const next = resolved === "dark" ? schemes.DARK : schemes.LIGHT;
+                const target = settings;
+                if (target.gtkInterfaceColorScheme !== next)
+                    target.gtkInterfaceColorScheme = next;
+            }
+            catch (error) {
+                console.error("Тема:", error instanceof Error ? error.message : error);
+            }
+        };
+        await applyColorScheme();
+        const loop = GLib.MainLoop.new(null, false);
+        // Node owns the thread. Blocking in MainLoop.run does not deliver named-pipe
+        // events on Windows, so GTK is pumped from a libuv timer: fast while events
+        // flow, slow while idle so a hidden palette costs almost nothing.
+        const context = loop.getContext();
+        let lastActive = Date.now();
+        const pump = () => {
+            try {
+                for (let step = 0; step < 64 && context.iteration(false); step++)
+                    lastActive = Date.now();
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : error);
+            }
+            pulse = setTimeout(pump, Date.now() - lastActive < 2000 ? 10 : 50);
+        };
+        pump();
+    }
+    try {
+        // The tray host compiles C# while the palette loads. Sequential startup misses the
+        // server's READY deadline when Vite is bundling at the same time.
+        let palette;
+        const deferred = [];
+        const withPalette = (run) => {
+            if (palette)
+                run(palette);
+            else
+                deferred.push(run);
+        };
+        const shellPromise = startDesktopShell(options.dataDirectory, {
+            onActivate: () => {
+                withPalette((item) => void item.invokeSelected());
+            },
+            onHotkey: () => {
+                withPalette((item) => void item.invokeSelected(true));
+            },
+            onSettings: () => {
+                withPalette((item) => item.openPage("/settings"));
+            },
+            onRestart: () => {
+                withPalette((item) => void item.restartProjector());
+            },
+            onQuit: () => {
+                withPalette((item) => void item.quitProjector());
+            },
+            onColorScheme: () => {
+                void applyColorScheme();
+            },
+        });
+        let shell;
+        try {
+            palette = await options.createPalette(baseUrl);
+        }
+        catch (error) {
+            shell = await shellPromise;
+            await shell.stop();
+            throw error;
+        }
+        for (const run of deferred.splice(0))
+            run(palette);
+        shell = await shellPromise;
+        let stopping = false;
+        let release = () => { };
+        const untilStop = new Promise((resolve) => {
+            release = resolve;
+        });
+        const configuredShortcut = async () => {
+            try {
+                const shortcut = JSON.parse(await readFile(join(options.dataDirectory, "launcher.json"), "utf8")).shortcut;
+                return typeof shortcut === "string" ? shortcut : "Ctrl+Alt+Space";
+            }
+            catch {
+                return "Ctrl+Alt+Space";
+            }
+        };
+        await shell.configure(await configuredShortcut()).catch((error) => {
+            console.error("Хоткей:", error instanceof Error ? error.message : error);
+        });
+        async function stop() {
+            if (stopping)
+                return;
+            stopping = true;
+            clearTimeout(pulse);
+            try {
+                await shell.stop();
+            }
+            catch (error) {
+                console.error("Трей stop:", error instanceof Error ? error.message : error);
+            }
+            try {
+                await stopWindowHost();
+            }
+            catch (error) {
+                console.error("Окно stop:", error instanceof Error ? error.message : error);
+            }
+            try {
+                palette?.dispose();
+            }
+            catch (error) {
+                console.error("Палитра:", error instanceof Error ? error.message : error);
+            }
+            server.close();
+            await rm(pidPath, { force: true });
+            await rm(launcherIdentityPath(options.dataDirectory), { force: true });
+            await rm(launcherTokenPath(options.dataDirectory), { force: true });
+            release();
+        }
+        const dispatch = async (requested) => {
+            if (requested === "quit") {
+                setTimeout(() => {
+                    void stop().catch((error) => {
+                        console.error("Остановка:", error instanceof Error ? error.message : error);
+                        release();
+                    });
+                }, 50);
+                return;
+            }
+            if (requested === "tray") {
+                await shell.configure(await configuredShortcut()).catch((error) => {
+                    console.error("Хоткей:", error instanceof Error ? error.message : error);
+                });
+                return;
+            }
+            if (requested === "toggle")
+                await palette.toggle();
+            else
+                await palette.show();
+        };
+        const missed = arm(dispatch);
+        process.once("SIGTERM", () => {
+            void stop();
+        });
+        process.once("SIGINT", () => {
+            void stop();
+        });
+        await dispatch(action);
+        for (const run of missed)
+            await run();
+        console.log("READY");
+        await untilStop;
+    }
+    finally {
+        clearTimeout(pulse);
+    }
+}

package/packages/core/modules/os/modules/windows/secrets.js

@@ -0,0 +1,110 @@
+import { runPowerShell } from "./ps.js";
+const HELPER = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class ProjectorVault {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct Native {
+    public int Flags;
+    public int Type;
+    public string TargetName;
+    public string Comment;
+    public long LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public string TargetAlias;
+    public string UserName;
+  }
+  [DllImport("advapi32", SetLastError=true, CharSet=CharSet.Unicode)]
+  public static extern bool CredWrite(ref Native credential, uint flags);
+  [DllImport("advapi32", SetLastError=true, CharSet=CharSet.Unicode)]
+  public static extern bool CredRead(string target, int type, int reserved, out IntPtr credential);
+  [DllImport("advapi32", SetLastError=true, CharSet=CharSet.Unicode)]
+  public static extern bool CredDelete(string target, int type, int flags);
+  [DllImport("advapi32")]
+  public static extern void CredFree(IntPtr credential);
+  public static bool Available() {
+    IntPtr credential;
+    CredRead("projector/probe-missing", 1, 0, out credential);
+    int error = Marshal.GetLastWin32Error();
+    if (credential != IntPtr.Zero) CredFree(credential);
+    return error == 1168 || error == 0;
+  }
+  public static string Read(string target) {
+    IntPtr credential;
+    if (!CredRead(target, 1, 0, out credential)) return "";
+    try {
+      var native = Marshal.PtrToStructure<Native>(credential);
+      if (native.CredentialBlob == IntPtr.Zero || native.CredentialBlobSize <= 0) return "";
+      var bytes = new byte[native.CredentialBlobSize];
+      Marshal.Copy(native.CredentialBlob, bytes, 0, bytes.Length);
+      return Convert.ToBase64String(bytes);
+    } finally { CredFree(credential); }
+  }
+  public static void Write(string target, string user, string comment, string value) {
+    var bytes = Encoding.UTF8.GetBytes(value);
+    var native = new Native();
+    native.Type = 1;
+    native.TargetName = target;
+    native.UserName = user;
+    native.Comment = comment;
+    native.Persist = 2;
+    native.CredentialBlobSize = bytes.Length;
+    native.CredentialBlob = Marshal.AllocHGlobal(bytes.Length);
+    try {
+      Marshal.Copy(bytes, 0, native.CredentialBlob, bytes.Length);
+      if (!CredWrite(ref native, 0)) throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+    } finally { Marshal.FreeHGlobal(native.CredentialBlob); }
+  }
+  public static void Remove(string target) { CredDelete(target, 1, 0); }
+}
+"@
+switch ($env:PROJECTOR_SECRET_OP) {
+  'available' { if ([ProjectorVault]::Available()) { 'yes' } else { 'no' } }
+  'get' { [ProjectorVault]::Read($env:PROJECTOR_SECRET_TARGET) }
+  'set' {
+    $value = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String(([Console]::In.ReadToEnd()).Trim()))
+    [ProjectorVault]::Write($env:PROJECTOR_SECRET_TARGET, $env:PROJECTOR_SECRET_ACCOUNT, $env:PROJECTOR_SECRET_LABEL, $value)
+  }
+  'delete' { [ProjectorVault]::Remove($env:PROJECTOR_SECRET_TARGET) }
+}
+`;
+function target({ service, account }) {
+    const clean = (value) => value.replace(/[\r\n\0]/g, "").slice(0, 200);
+    return `projector:${clean(service)}:${clean(account)}`;
+}
+let availableCache;
+export function secretsAvailable() {
+    availableCache ??= runPowerShell(HELPER, { env: { PROJECTOR_SECRET_OP: "available" } }).then(({ stdout }) => stdout.trim() === "yes", () => false);
+    return availableCache;
+}
+export async function getSecret(key) {
+    const { stdout } = await runPowerShell(HELPER, {
+        env: { PROJECTOR_SECRET_OP: "get", PROJECTOR_SECRET_TARGET: target(key) },
+    });
+    const encoded = stdout.trim();
+    if (!encoded)
+        return undefined;
+    return Buffer.from(encoded, "base64").toString("utf8");
+}
+export async function setSecret(key, label, value) {
+    await runPowerShell(HELPER, {
+        env: {
+            PROJECTOR_SECRET_OP: "set",
+            PROJECTOR_SECRET_TARGET: target(key),
+            PROJECTOR_SECRET_ACCOUNT: key.account,
+            PROJECTOR_SECRET_LABEL: label,
+        },
+        input: Buffer.from(value, "utf8").toString("base64"),
+    });
+}
+export async function deleteSecret(key) {
+    await runPowerShell(HELPER, {
+        env: { PROJECTOR_SECRET_OP: "delete", PROJECTOR_SECRET_TARGET: target(key) },
+    });
+}

package/packages/core/modules/os/modules/windows/shell.js

@@ -0,0 +1,288 @@
+import { createInterface } from "node:readline";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hotkeyPath, hotkeys } from "./shortcut.js";
+import { spawnPowerShell } from "./ps.js";
+const iconPath = fileURLToPath(new URL("../../../../../../resources/icons/64.png", import.meta.url));
+const host = String.raw `
+try { [Console]::TreatControlCAsInput = $true } catch {}
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition 'using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Windows.Forms;
+public delegate void HotkeyHandler();
+public delegate void ColorHandler();
+public static class ProjectorHotkey {
+  [DllImport("user32.dll")] public static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+  [DllImport("user32.dll")] public static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+  [DllImport("user32.dll")] public static extern bool DestroyIcon(IntPtr handle);
+}
+public class ProjectorCommands {
+  readonly ConcurrentQueue<string> queue = new ConcurrentQueue<string>();
+  public void Start() {
+    var thread = new Thread(() => {
+      try {
+        var reader = new StreamReader(Console.OpenStandardInput(), new UTF8Encoding(false));
+        string line;
+        while ((line = reader.ReadLine()) != null) queue.Enqueue(line);
+        queue.Enqueue("quit");
+      } catch {}
+    });
+    thread.IsBackground = true;
+    thread.Start();
+  }
+  public string[] Drain() {
+    var lines = new List<string>();
+    string line;
+    while (queue.TryDequeue(out line)) lines.Add(line);
+    return lines.ToArray();
+  }
+}
+public class ProjectorTrayForm : Form {
+  public HotkeyHandler Hotkey;
+  public ColorHandler Colors;
+  protected override void WndProc(ref Message m) {
+    if (m.Msg == 0x0312 && Hotkey != null) Hotkey();
+    if (m.Msg == 0x001A && Colors != null && m.LParam != IntPtr.Zero) {
+      var setting = Marshal.PtrToStringUni(m.LParam);
+      if (setting == "ImmersiveColorSet") Colors();
+    }
+    base.WndProc(ref m);
+  }
+}' -ReferencedAssemblies System.Windows.Forms
+function Emit([string]$text) {
+  [Console]::Out.WriteLine($text)
+  [Console]::Out.Flush()
+}
+$script:form = New-Object ProjectorTrayForm
+$form.ShowInTaskbar = $false
+$form.Opacity = 0
+$form.Hotkey = { Emit "hotkey" }
+$form.Colors = { Emit "colors" }
+$notify = New-Object System.Windows.Forms.NotifyIcon
+$notify.Text = "Projector"
+try {
+  $bitmap = New-Object System.Drawing.Bitmap $env:PROJECTOR_TRAY_ICON
+  $handle = $bitmap.GetHicon()
+  try { $notify.Icon = [System.Drawing.Icon]::FromHandle($handle).Clone() }
+  finally { [void][ProjectorHotkey]::DestroyIcon($handle); $bitmap.Dispose() }
+} catch {
+  $notify.Icon = [System.Drawing.SystemIcons]::Application
+}
+$notify.Visible = $true
+$menu = New-Object System.Windows.Forms.ContextMenuStrip
+function Add-Item([string]$label, [string]$action) {
+  $item = $menu.Items.Add($label)
+  $null = $item.Add_Click({ Emit $action }.GetNewClosure())
+}
+Add-Item "Открыть поиск" "activate"
+Add-Item "Настройки" "settings"
+$null = $menu.Items.Add("-")
+Add-Item "Перезапустить" "restart"
+Add-Item "Выйти из Projector" "quit"
+$notify.ContextMenuStrip = $menu
+$notify.Add_MouseClick({
+  param($sender, $mouse)
+  if ($mouse.Button -eq [System.Windows.Forms.MouseButtons]::Left) { Emit "activate" }
+})
+$script:hotkeyId = 1
+function Set-Hotkey([string]$id, [string]$mod, [string]$vk) {
+  [void][ProjectorHotkey]::UnregisterHotKey($form.Handle, $script:hotkeyId)
+  if ($mod -eq "clear") { Emit "result $id cleared"; return }
+  $ok = [ProjectorHotkey]::RegisterHotKey($form.Handle, $script:hotkeyId, [uint32]$mod, [uint32]$vk)
+  Emit "result $id $(if ($ok) { 'registered' } else { 'busy' })"
+}
+$script:commands = New-Object ProjectorCommands
+$script:commands.Start()
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 50
+$timer.Add_Tick({
+  $lines = $script:commands.Drain()
+  if ($null -eq $lines) { return }
+  foreach ($line in @($lines)) {
+    if ($line -eq "quit") { $script:form.Close(); return }
+    $parts = $line.Trim().Split(" ")
+    if ($parts[0] -eq "hotkey" -and $parts.Length -ge 3) {
+      $vk = if ($parts.Length -ge 4) { $parts[3] } else { "0" }
+      Set-Hotkey $parts[1] $parts[2] $vk
+    }
+  }
+})
+$form.Add_FormClosing({
+  $timer.Stop()
+  [void][ProjectorHotkey]::UnregisterHotKey($form.Handle, $script:hotkeyId)
+  $notify.Visible = $false
+  $notify.Dispose()
+})
+$form.Add_Shown({
+  $form.Hide()
+  $timer.Start()
+  Emit "ready"
+})
+[System.Windows.Forms.Application]::Run($form)
+`;
+const idle = {
+    configure() {
+        return Promise.reject(new Error("Трей недоступен"));
+    },
+    stop: async () => undefined,
+};
+const defaultReplyTimeout = 3000;
+function spawnHost() {
+    return spawnPowerShell(host, { sta: true, env: { PROJECTOR_TRAY_ICON: iconPath } });
+}
+/**
+ * Win32 tray icon and global hotkey. Lives beside the GTK palette and talks over stdin.
+ * `spawnProcess` is replaceable so the line protocol can be exercised without Windows.
+ */
+export async function startDesktopShell(dataDirectory, handlers, spawnProcess = spawnHost, replyTimeout = defaultReplyTimeout) {
+    try {
+        return await launch(dataDirectory, handlers, spawnProcess, replyTimeout);
+    }
+    catch (error) {
+        console.error("Трей:", error instanceof Error ? error.message : error);
+        await remember(dataDirectory, "", false);
+        return idle;
+    }
+}
+async function launch(dataDirectory, handlers, spawnProcess, replyTimeout) {
+    const child = spawnProcess();
+    let stopped = false;
+    let nextId = 0;
+    // Replies carry the request id, so an answer that arrives after its timeout cannot
+    // be mistaken for the answer to the next request.
+    const pending = new Map();
+    const failPending = () => {
+        for (const request of [...pending.values()])
+            request.settle("busy");
+    };
+    child.on("error", (error) => console.error("Трей:", error.message));
+    child.once("exit", () => failPending());
+    process.once("exit", () => {
+        if (!stopped)
+            child.kill();
+    });
+    const stderr = child.stderr;
+    if (stderr) {
+        stderr.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (text)
+                console.error("Трей:", text);
+        });
+    }
+    const input = child.stdin;
+    const output = child.stdout;
+    if (!input || !output)
+        throw new Error("Не удалось запустить трей");
+    input.on("error", () => undefined);
+    const lines = createInterface({ input: output });
+    lines.on("line", (line) => {
+        const text = line.trim();
+        if (text === "ready")
+            return;
+        const reply = /^result (\S+) (registered|cleared|busy)$/.exec(text);
+        if (reply) {
+            const request = pending.get(reply[1]);
+            if (!request)
+                return;
+            const result = reply[2];
+            pending.delete(reply[1]);
+            void remember(dataDirectory, result === "registered" ? request.shortcut : "", result === "registered")
+                .catch(() => undefined)
+                .finally(() => request.settle(result));
+            return;
+        }
+        if (text === "hotkey")
+            handlers.onHotkey();
+        else if (text === "colors")
+            handlers.onColorScheme?.();
+        else if (text === "activate")
+            handlers.onActivate();
+        else if (text === "settings")
+            handlers.onSettings();
+        else if (text === "restart")
+            handlers.onRestart();
+        else if (text === "quit")
+            handlers.onQuit();
+    });
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("Трей не ответил"));
+        }, 8000);
+        const onLine = (line) => {
+            if (line.trim() !== "ready")
+                return;
+            clearTimeout(timer);
+            lines.off("line", onLine);
+            resolve();
+        };
+        lines.on("line", onLine);
+        child.once("exit", (code, signal) => {
+            clearTimeout(timer);
+            reject(new Error(`Трей завершился (${code ?? signal ?? "?"})`));
+        });
+    });
+    let chain = Promise.resolve();
+    return {
+        configure(shortcut) {
+            const task = chain.then(() => new Promise((resolve) => {
+                const spec = hotkeys[shortcut];
+                if (shortcut && !spec) {
+                    resolve("busy");
+                    return;
+                }
+                const id = String(++nextId);
+                const timer = setTimeout(() => {
+                    pending.delete(id);
+                    resolve("busy");
+                }, replyTimeout);
+                pending.set(id, {
+                    shortcut,
+                    settle: (result) => {
+                        clearTimeout(timer);
+                        pending.delete(id);
+                        resolve(result);
+                    },
+                });
+                input.write(spec ? `hotkey ${id} ${spec.mod} ${spec.vk}\n` : `hotkey ${id} clear\n`);
+            }));
+            chain = task.then(() => undefined, () => undefined);
+            return task;
+        },
+        async stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            failPending();
+            try {
+                input.write("quit\n");
+            }
+            catch {
+                /* stdin already closed */
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    child.kill();
+                    resolve();
+                }, 2000);
+                child.once("exit", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+            await remember(dataDirectory, "", false);
+        },
+    };
+}
+async function remember(dataDirectory, shortcut, active) {
+    await mkdir(dirname(hotkeyPath(dataDirectory)), { recursive: true });
+    await writeFile(hotkeyPath(dataDirectory), JSON.stringify({ shortcut, active }));
+}