feat(cli): turn key binding files into KDE static shortcuts

komorebi users keep their bindings to komorebic in a file of skhd, whkd or
sxhkd. On Plasma under Wayland no client sees the keys of another, and the
program that runs a command on a key is KDE's global shortcut daemon, which runs
inside KWin. A binding that is one combo, pressed, the same in every
application, in a file without modes, can be a static shortcut: a .desktop file
that KWin reads by itself, that shows in System Settings and that works with no
komorebi process at all.

komorebic hotkeys compile reads a file of any of the three formats, plans it
with komorebi-hotkeys in the mode it is given (auto, engine or static; the
default is the crate's), prints the diagnostics of reading and planning, and
writes the static shortcuts to $XDG_DATA_HOME/kglobalaccel or --output,
replacing the files it wrote before and no other. --strict refuses a file with a
warning or an error before writing anything, --dry-run says what a write would
change, and --reload hands each new file to the running KWin. komorebic
export-kde-shortcuts keeps the spike's interface for an skhdrc, in the static
mode. Both are thin: the reading, the plan and the files are the crate's. The
bindings that need the engine are counted; the daemon does not run them yet.

docgen gives a subcommand of a subcommand a page of its own
(hotkeys-compile.md). KOMOREBI_CONFIG_HOME, or ~/.config/komorebi, is where
komorebic looks for a file it is not given.

komorebic check gains a section for the key bindings, between the configuration
and the desktop: the first key binding file of the config home, how many
bindings it has and where they go, the lines that cannot be read (a warning, and
the first five) and the bindings not realized as their own daemon would (a
note), and whether the generated files in the shortcut directory are the ones
hotkeys compile would write now (a warning with how many to add, to change and
to remove). --configuration-only keeps it, as it looks at files.

The VM test vm-keys-static boots a Plasma session with shortcut files that
hotkeys compile wrote into the system profile at build time, presses their keys
through QEMU's keyboard, and sees each command run, a % in one of them included;
then it writes a binding in the middle of the session with export-kde-shortcuts
--reload and presses it. The library gains Keys, which sends a combo as KDE
writes it through QEMU's sendkey.
This commit is contained in:
LGUG2Z committed 2026-10-28 07:20:57 -07:00
1 parent a2e7f12bd3
commit e1a227434b
27 files changed
+1585 -36

No files matched your search

Generated
+1
View File
@@ -2581,6 +2581,7 @@ dependencies = [
"dirs 6.0.0",
"fs-tail",
"komorebi-client",
"komorebi-hotkeys",
"lazy_static",
"pastey",
"schemars 1.2.3",
+17 -6
View File
@@ -86,8 +86,9 @@ without a checkout of the toolchain.
unlocked (`monitor_reconciliator`, `reconcile`, `kwin::power`), sends its
subscribers a notification of each event, message and change of the monitors
it handles (`notify_subscribers`), and is configured by a `komorebi.json` that
it reads and reads again when it changes (`static_config`), and checks it, and
the desktop it runs on, for mistakes without the daemon (`check`).
it reads and reads again when it changes (`static_config`), and checks it, the
key binding file, and the desktop it runs on, for mistakes without the daemon
(`check`).
- [`komorebi-client`](komorebi-client): a library that sends messages to the
daemon, reads its answers, subscribes to its notifications, and re-exports
the types they are made of.
@@ -101,7 +102,9 @@ without a checkout of the toolchain.
- [`komorebic`](komorebic): the command line. A subcommand that asks something
of the daemon is one message on its socket; `quickstart`, `enable-autostart`,
`disable-autostart`, `start`, `check`, `configuration`, `log`, `data-directory`,
`completions` and the hidden `docgen` work without the daemon.
`completions` and the hidden `docgen` work without the daemon, and so do
`export-kde-shortcuts` and `hotkeys compile`, which write the bindings of a
key binding file that KDE can run by itself as shortcut files.
- [`version`](version): the version string every binary reports.
The layouts, which turn a work area and a number of containers into a rectangle
@@ -287,9 +290,11 @@ module's `config` option is typed from that schema (`nix/komorebi-options.nix`,
`check` reads the file the way the daemon does and says in words what is wrong with it: JSON that
does not parse, with the line, a value komorebi does not read, a key that is not a setting (with
the nearest one that is), a workspace that is not tiled, and an applications file that is not
there. It also looks at the desktop (a Plasma session on Wayland, KWin 6 on the session bus, the
daemon and its script in KWin, and what starts komorebi at login), unless `--configuration-only`
leaves that out. It exits with status 1 if something is an error.
there. It looks at the key binding file as well (how many bindings it has, the lines that cannot
be read, and whether the shortcut files `hotkeys compile` wrote are the ones it would write now),
and at the desktop (a Plasma session on Wayland, KWin 6 on the session bus, the daemon and its
script in KWin, and what starts komorebi at login), unless `--configuration-only` leaves that out.
It exits with status 1 if something is an error.
A program such as a status bar can subscribe to the daemon's notifications: it
listens on a socket of its own, and after each event, each message and each
@@ -316,6 +321,12 @@ the palette of a picture is made and kept in the cache directory. A monitor or a
can have a wallpaper, which the Plasma shell is asked to show when the workspace comes into view,
and which gives the borders the colors of its palette.
Key bindings are written in the format of skhd, whkd or sxhkd. `komorebi-hotkeys`
reads such a file into one model and sorts its bindings into static shortcuts,
which KDE runs by itself from a `.desktop` file, and those that need komorebi
to register the keys and decide what each press does. `komorebic hotkeys
compile` writes the static shortcuts.
## Documentation
The user guide starts at [`docs/index.md`](docs/index.md),
+1 -1
View File
@@ -8,7 +8,7 @@ Options:
Path to a static configuration JSON file
--configuration-only
Look at the configuration only, not at the desktop
Look at the configuration and the key bindings only, not at the desktop
-h, --help
Print help
+22
View File
@@ -0,0 +1,22 @@
```text
Turn an skhdrc into KDE global shortcuts (they work over RDP, unlike evdev hotkey daemons)
Usage: export-kde-shortcuts [OPTIONS]
Options:
-s, --skhdrc <SKHDRC>
The skhdrc to translate [default: skhdrc in the komorebi config directory]
-o, --output <OUTPUT>
Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
--reload
Activate shortcuts that are new straight away, instead of at the next login
--dry-run
Show the shortcuts that would be written without writing anything
-h, --help
Print help
```
+41
View File
@@ -0,0 +1,41 @@
```text
Plan the bindings of a key binding file, and write those that are static shortcuts as KDE shortcut
files
Usage: compile [OPTIONS] [FILE]
Arguments:
[FILE]
The key binding file [default: the first of skhdrc, whkdrc and sxhkdrc in the komorebi
config directory]
Options:
-f, --format <FORMAT>
The format of the file [default: from the end of its name: skhdrc, whkdrc or sxhkdrc]
[possible values: skhd, whkd, sxhkd]
-m, --mode <MODE>
Which bindings are static shortcuts: none (engine), every binding a shortcut file can
express (auto), or only those, leaving the others out (static)
[default: engine]
[possible values: auto, engine, static]
-o, --output <OUTPUT>
Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
--strict
Write nothing, and fail, when a diagnostic is a warning or an error: something in the file
is not realized the way its own hotkey daemon realizes it
--reload
Activate shortcuts that are new straight away, instead of at the next login
--dry-run
Show the shortcuts that would be written without writing anything
-h, --help
Print help
```
+15
View File
@@ -0,0 +1,15 @@
```text
Turn a key binding file (skhdrc, whkdrc, sxhkdrc) into KDE global shortcuts
Usage: hotkeys <COMMAND>
Commands:
compile Plan the bindings of a key binding file, and write those that are static shortcuts as KDE
shortcut files
help Print this message or the help of the given subcommand(s)
Options:
-h, --help
Print help
```
+37 -3
View File
@@ -964,8 +964,9 @@ configuration or a wallpaper that is not there, a wallpaper no theme can be made
that is only a name, which is not tiled, and a workspace that appends windows to a container and
has placement rules, which are not used then (the workspace's `window_container_behaviour`, or the
file's when it has none). [`check_configuration`] also returns the [`Wants`] of the file: whether
it draws borders, which animation style it asks for and whether it has wallpapers. `komorebic`
prints [`Report::render`] and exits with status 1 if [`Report::has_errors`].
it draws borders, which animation style it asks for and whether it has wallpapers. The key binding
file has a section of its own, which `komorebic` makes (see [Key bindings](#key-bindings)).
`komorebic` prints [`Report::render`] and exits with status 1 if [`Report::has_errors`].
[`check_environment`] looks at the desktop, with D-Bus calls of its own on the session bus (they
are in the table of [PLATFORM.md](PLATFORM.md#d-bus)), and `komorebic check --configuration-only`
@@ -1633,6 +1634,27 @@ daemons: skhd (macOS), whkd (Windows) and sxhkd (X11).
- [`tests/fixtures`](../../komorebi-hotkeys/tests/fixtures): the corpus, `<case>.skhdrc`,
`<case>.whkdrc` and `<case>.sxhkdrc`, each case in every format that can express it.
### The front end
[`komorebic/src/hotkeys.rs`](../../komorebic/src/hotkeys.rs) is the command line over the
crate, and decides nothing about what a file means. `komorebic hotkeys compile` reads a file (by default the
first of `skhdrc`, `whkdrc` and `sxhkdrc` in the komorebi config directory, its format from
the end of its name), plans it in the mode it is given (by default `PlanMode::default()`),
prints the diagnostics of reading and of planning on standard error, and writes the static
shortcuts to `$XDG_DATA_HOME/kglobalaccel` or `--output`, replacing the files it wrote before.
With `--strict`, a diagnostic that is a warning or an error stops it before it writes
anything. `--dry-run` writes nothing and prints what a write would change, and `--reload`
hands each new file to the running KWin, which otherwise reads them at the next login.
`komorebic export-kde-shortcuts` is the same for an skhdrc, in `PlanMode::Static`.
`komorebic check` has a section for the key bindings, between the configuration and the desktop.
`hotkeys::check` finds the file as `compile` does, reads and plans it in the default mode, and
returns [`Finding`]s: how many bindings the file has and where they go, how many lines cannot be
read and left out (a warning) and how many bindings are not realized as their own daemon would
(a note), each with the first five, and whether the generated files in the shortcut directory are
the ones `kde::diff` says that plan would write. It reads no file the desktop has no part in, so
`--configuration-only` keeps it.
### What is guaranteed, and by what
| Rule | Enforced by | Proof | Escape hatch |
@@ -1654,6 +1676,12 @@ daemons: skhd (macOS), whkd (Windows) and sxhkd (X11).
| Stopping the engine gives every key back | test, of the effects; carrying them out is the daemon's | `start_activates_the_default_mode_and_stop_gives_everything_back` | none |
| The engine does no I/O and reads no clock | convention only | none | none |
| The whkd reader reads a whkdrc as whkd does | test, on the files it is given | `every_whkdrc_of_the_corpus_reads_as_whkd_reads_it`, `the_example_of_whkds_readme_reads_as_whkd_reads_it` | none |
| `hotkeys compile` writes the static shortcuts of the plan and nothing else, from a file of any format | test, through the binary | `compile_writes_the_same_shortcut_files_from_each_format`, `compile_in_engine_mode_writes_no_shortcut_and_removes_the_ones_it_wrote` | none |
| `komorebic check` reads the key binding file `hotkeys compile` would read, the way it does | framework path: `check` and `export` share `find` and `diagnostics`, and call the same `parse` and `plan` | `the_first_file_of_the_three_formats_is_the_one_that_is_read`, `the_key_binding_file_of_the_config_home_is_read_and_a_line_it_cannot_read_is_a_warning` | none |
| A line of the key binding file that cannot be read does not fail `komorebic check` | test, through the binary | `the_key_binding_file_of_the_config_home_is_read_and_a_line_it_cannot_read_is_a_warning` | none |
| `komorebic check` says when the shortcut files are not the ones `hotkeys compile` would write | test | `shortcut_files_that_are_not_the_ones_of_the_plan_are_a_warning_that_says_how_many`, `shortcut_files_the_file_does_not_call_for_are_a_warning_until_compile_replaces_them` | none |
| `--strict` writes nothing when a diagnostic is a warning or an error | test, through the binary | `strict_refuses_a_file_with_a_warning_and_writes_nothing` | none |
| KWin runs a static shortcut's command on its key, from the system profile at the start of a session and from the user's directory after `--reload` | VM test | `vm-keys-static` | none |
## Where to look in the code
@@ -1686,7 +1714,8 @@ daemons: skhd (macOS), whkd (Windows) and sxhkd (X11).
format.
- [`komorebi/src/check.rs`](../../komorebi/src/check.rs): the checks of `komorebic check`, with
their tests; [`komorebic/tests/check.rs`](../../komorebic/tests/check.rs) runs the command on
configurations and on buses that are not there, and reads what it prints and its exit status;
configurations, on key binding files and on buses that are not there, and reads what it prints
and its exit status;
[`nix/tests/vm/suites/check`](../../nix/tests/vm/suites/check/test.py), the desktop check against
a real KWin, with the daemon running, with its script gone, with no daemon and with no KWin.
- [`komorebi/src/process_event.rs`](../../komorebi/src/process_event.rs): what each event
@@ -1836,6 +1865,11 @@ daemons: skhd (macOS), whkd (Windows) and sxhkd (X11).
[`sxhkd.rs`](../../komorebi-hotkeys/src/sxhkd.rs);
[`plan.rs`](../../komorebi-hotkeys/src/plan.rs) and [`kde.rs`](../../komorebi-hotkeys/src/kde.rs)
for the shortcuts, [`engine.rs`](../../komorebi-hotkeys/src/engine.rs) for the engine.
- [`komorebic/src/hotkeys.rs`](../../komorebic/src/hotkeys.rs): `export-kde-shortcuts` and
`hotkeys compile`, and the key bindings section of `komorebic check`;
[`komorebic/tests/hotkeys.rs`](../../komorebic/tests/hotkeys.rs), what they write.
- [`nix/tests/vm/suites/keys-static`](../../nix/tests/vm/suites/keys-static/test.py): static
shortcuts run by a real KWin.
- [`komorebi-hotkeys/tests`](../../komorebi-hotkeys/tests): the corpus test and the comparison
with `whkd-parser`.
- [`nix/nixos-module.nix`](../../nix/nixos-module.nix): the NixOS module;
+3
View File
@@ -747,6 +747,9 @@ The cost is the robustness of static shortcuts: the engine works only while komo
and a komorebi process that was killed leaves its keys registered and dead until they are
released.
Which of the two is the default is still open for a decision. `PlanMode::default()` is the
one place it is set, and `komorebic hotkeys compile` takes its default from there.
## Why does the engine grab and give back keys, instead of using KDE's own key sequences?
Because KDE's do not work for this, as measured on KWin 6.8.1 (2026-10-27). kglobalacceld
+36 -1
View File
@@ -292,6 +292,31 @@ At time of writing (2026-10-27), the headless KWin of the VM tests (Plasma 6.8)
major version from it. The check does not need the answer: without the line it says that KWin is
there and its version could not be read.
## Global shortcuts
KDE's global shortcut daemon runs inside KWin 6.8: `kwin_wayland` owns `org.kde.kglobalaccel`
on the session bus, and there is no separate `kglobalacceld` process. A KWin started with
`--no-global-shortcuts`, as the headless VM tests start it, has none.
A static shortcut is a `.desktop` file in a `kglobalaccel` directory with
`X-KDE-GlobalAccel-CommandShortcut=true` and the key in `X-KDE-Shortcuts`; KWin runs its
`Exec` line on the key. `komorebic hotkeys compile` and `komorebic export-kde-shortcuts`
write such files. What follows was measured at time of writing (2026-10-27) on KWin 6.8.1:
- KWin reads the files when it starts: those in `$XDG_DATA_HOME/kglobalaccel` and those in
`share/kglobalaccel` of the data directories, the system profile of NixOS among them.
- A file added while KWin runs is not read until something calls
`doRegister(["<file name>", "_launch", "", ""])` on `/kglobalaccel`, which is what `--reload`
does for each new file (through `busctl`); the shortcut then works at once. A file whose
content changed keeps the old content until the next login, and a removed file stays
registered until then too.
- In `Exec`, `%` starts a field code, so a command's `%` is written `%%`.
- A static shortcut ran its command 165 to 436 ms after the key, 233 ms at the median, over 8
presses, in a virtual machine under HVF with 4 cores. A key held for 1.5 s ran the command
once.
- The VM test `vm-keys-static` presses the keys of shortcut files in the system profile, and of
one written and handed over in the middle of the session.
## Files and directories
| Path | What | Lifetime |
@@ -309,12 +334,18 @@ there and its version could not be read.
| `$XDG_CACHE_HOME/komorebi` (`~/.cache/komorebi`) | the palettes made from wallpapers, a file for each picture and variant, `NAME-HASH.base16.VARIANT.json` | never removed by komorebi; made again when the picture's path, size or time of last change differ |
| `$XDG_DATA_HOME/komorebi/komorebi.log.YYYY-MM-DD` | the daemon's log, with colors, which `komorebic log` follows | a file a day (the UTC date), never removed by komorebi |
| `$XDG_DATA_HOME/komorebi/komorebi_plaintext.log.YYYY-MM-DD` | the same log without colors | as above |
| `$XDG_DATA_HOME/kglobalaccel/komorebi-*.desktop` | the static shortcuts `komorebic hotkeys compile` and `komorebic export-kde-shortcuts` write, each with `X-Komorebi-Generated=true` | replaced at every write: the files with that key are removed, and no other |
| `$KOMOREBI_CONFIG_HOME/{skhdrc,whkdrc,sxhkdrc}` | the key binding file `komorebic hotkeys compile` reads when it is given none (the first that exists), and the skhdrc of `export-kde-shortcuts` | the user's |
Without `XDG_RUNTIME_DIR` the bridge and the socket are in `komorebi` in the local data
directory instead, with the logs (see [`XDG_DATA_HOME`](#xdg_data_home)).
## What `komorebic check` looks at
The key binding file is the first of `skhdrc`, `whkdrc` and `sxhkdrc` in `$KOMOREBI_CONFIG_HOME`,
and the shortcut files it compares with are the generated `komorebi-*.desktop` files in
`$XDG_DATA_HOME/kglobalaccel`; neither needs a bus.
Apart from the bus, it looks at the files that start komorebi at login, in this order, and says which
it found first: `$XDG_CONFIG_HOME/autostart/komorebi.desktop` (the autostart entry),
`$XDG_CONFIG_HOME/systemd/user/komorebi.service`, `/etc/systemd/user/komorebi.service` and
@@ -348,7 +379,9 @@ either. An address with no bus behind it is the first error under [No KWin](#no-
The config home, where komorebi looks for `komorebi.json`: a directory, in which `komorebic
configuration` and the daemon look for the file. Without it the config home is
`~/.config/komorebi`, whatever `XDG_CONFIG_HOME` is. When it is set and is not a directory, the
daemon and `komorebic` panic when they first need the config home, and say so.
daemon and `komorebic` panic when they first need the config home, and say so. Environment
variables in it are expanded (`$HOME/komorebi`). `komorebic hotkeys compile` looks in it for the
key binding file it is not given.
### `XDG_RUNTIME_DIR`
@@ -374,6 +407,8 @@ The logs are written to `$XDG_DATA_HOME/komorebi` (`~/.local/share/komorebi` if
`XDG_DATA_HOME` is not set), which the daemon makes before anything else: a home it cannot
write to stops it at once. When `XDG_RUNTIME_DIR` is not set, the bridge and the socket go
there too.
`komorebic` writes static shortcuts to `$XDG_DATA_HOME/kglobalaccel` unless it is given
`--output`.
### `KWIN_EFFECTS_FORCE_ANIMATIONS`
+19
View File
@@ -184,6 +184,25 @@ the run.
pointer lands within a pixel of where it is asked. The program itself is
[`komorebi_vm/uinput.py`](../../nix/tests/vm/lib/komorebi_vm/uinput.py),
whose arithmetic the `vm-lib` check tests.
- `Keys(machine).send("alt-shift-k")` presses a combo on the machine's
keyboard, written as KDE writes it in lower case with `-` between the keys
(`meta` and `super` are the left Super key).
## Pressing keys
A key test presses keys with QEMU's `sendkey` (`machine.send_key`), through
`Keys`. The key reaches the guest's kernel as a key of the machine's virtual
keyboard, and KWin sees it as it sees a person's: a global shortcut fires on
it, and any other key goes to the focused window. QEMU holds the keys for 100
ms, less than the delay before a key repeats. Phase 0 drove keys from a uinput
device inside the guest instead, as the pointer is driven now; `sendkey` needs
no helper program for keys, and on x86_64 under KVM `vm-keys-static` passed with
it on its first run (2026-10-27).
Global shortcuts need the session node: the headless KWin runs with
`--no-global-shortcuts`, so it has no `org.kde.kglobalaccel`. A static
shortcut written into the system profile by the suite's `node` (as
`vm-keys-static` does) is found when the session starts.
Poll for what the test needs with `wait_for`. A fixed sleep is too long on
KVM and too short on TCG.
+2 -1
View File
@@ -76,7 +76,8 @@ changes size, is unplugged or is plugged in, and
[Sleeping and locking](usage/sleeping-and-locking.md) what it does when the machine wakes up and
the screen is unlocked.
[Checking the setup](usage/checking-the-setup.md) explains how `komorebic check` finds the
mistakes in a configuration, and what is missing from the desktop, before the daemon does.
mistakes in a configuration and a key binding file, and what is missing from the desktop, before
the daemon does.
[Subscribing to notifications](usage/subscribing-to-notifications.md) explains how a program
such as a status bar follows what komorebi does. The [CLI reference](cli/start.md) has a page
for every `komorebic` command, generated from its help.
+31 -8
View File
@@ -1,8 +1,8 @@
# Checking the setup
[`komorebic check`](../cli/check.md) reads your configuration the way the daemon does, looks at the
desktop komorebi has to run on, and says in words what is wrong. It does not need the daemon to be
running, and it changes nothing.
[`komorebic check`](../cli/check.md) reads your configuration the way the daemon does, reads your
key binding file, looks at the desktop komorebi has to run on, and says in words what is wrong. It
does not need the daemon to be running, and it changes nothing.
```sh
komorebic check
@@ -12,10 +12,10 @@ komorebic check --configuration-only
It reads `komorebi.json` in the [config home](configuration.md#where-the-file-is), or the file
`--komorebi-config` names (`-k`; environment variables in the path are replaced). It prints a
section of findings for the configuration and one for the desktop, then the number of errors and
warnings, and exits with status 1 if and only if a finding is an error, so a script can run it
before it starts the daemon. `--configuration-only` leaves the desktop out, for a machine that is
not the one komorebi will run on: a build that checks a file, say.
section of findings for the configuration, one for the key bindings and one for the desktop, then
the number of errors and warnings, and exits with status 1 if and only if a finding is an error, so
a script can run it before it starts the daemon. `--configuration-only` leaves the desktop out, for
a machine that is not the one komorebi will run on: a build that checks a file, say.
## What a finding says
@@ -82,9 +82,32 @@ The first section says where komorebi looks, and then what it finds in the file:
The check takes the keys it knows from the schema of the types the daemon reads the file with, at
every level, so it knows every setting komorebi reads.
## The key bindings
The second section is about the key binding file `komorebic hotkeys compile` would read: the first
of `skhdrc`, `whkdrc` and `sxhkdrc` in the config home. It reads the file as
[`hotkeys compile`](../cli/hotkeys-compile.md) does, plans it in the mode `hotkeys compile` uses
when it is not given one, and looks at:
- **No file.** A `note`, with where key bindings come from: a key binding file made into shortcuts
by `komorebic hotkeys compile`, or shortcuts set up in System Settings.
- **The bindings.** `ok` with the file, how many bindings it has, and how many of them become
shortcut files and how many are for komorebi's engine.
- **Lines that cannot be read.** A `warning` that says how many are left out, and shows the first
five with their line numbers. The rest of the file is read all the same.
- **Bindings that are not realized as the file's own hotkey daemon would.** A `note` with how many,
and the first five: a left Alt that is the same as the right one, say, since KDE does not tell
them apart.
- **Shortcut files that are not the plan's.** A `warning` when the generated files in
`$XDG_DATA_HOME/kglobalaccel` are not the ones `komorebic hotkeys compile` would write for the
file now: how many to add, to change and to remove. The hint is the command that makes them
match. Otherwise `ok`.
`--configuration-only` leaves this section in: it looks at files, not at the desktop.
## The desktop
The second section is about the desktop `komorebic check` runs in, which has to be the session
The third section is about the desktop `komorebic check` runs in, which has to be the session
komorebi runs in: it asks the session bus of the environment it is run from, so run it in a
terminal of the Plasma session, not over ssh. It looks, in this order, at:
+1
View File
@@ -6,6 +6,7 @@ edition = "2024"
[dependencies]
komorebi-client = { path = "../komorebi-client", default-features = false }
komorebi-hotkeys = { path = "../komorebi-hotkeys" }
version = { path = "../version" }
clap = { workspace = true }
+707
View File
@@ -0,0 +1,707 @@
//! The key binding subcommands: `export-kde-shortcuts` and `hotkeys`.
//!
//! Both are front ends over [`komorebi_hotkeys`]: they read a key binding file
//! ([`komorebi_hotkeys::parse`]), sort its bindings into KDE shortcut files and the engine's
//! ([`komorebi_hotkeys::plan::plan`]), print what the crate has to say about the file, and write the
//! shortcut files ([`komorebi_hotkeys::kde::write`]). `export-kde-shortcuts` does this for an
//! skhdrc, as static shortcuts only; `hotkeys compile` for a file of any of the three formats, in
//! any [`PlanMode`].
use crate::HOME_DIR;
use clap::Parser;
use clap::Subcommand;
use clap::ValueEnum;
use color_eyre::eyre;
use komorebi_client::check::Finding;
use komorebi_hotkeys::Diagnostic;
use komorebi_hotkeys::Format;
use komorebi_hotkeys::ParseOptions;
use komorebi_hotkeys::Parsed;
use komorebi_hotkeys::Severity;
use komorebi_hotkeys::kde;
use komorebi_hotkeys::plan::Plan;
use komorebi_hotkeys::plan::PlanMode;
use komorebi_hotkeys::plan::PlanOptions;
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
use std::process::Stdio;
#[derive(Parser)]
pub struct ExportKdeShortcuts {
/// The skhdrc to translate [default: skhdrc in the komorebi config directory]
#[clap(short, long)]
skhdrc: Option<PathBuf>,
/// Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
#[clap(short, long)]
output: Option<PathBuf>,
/// Activate shortcuts that are new straight away, instead of at the next login
#[clap(long)]
reload: bool,
/// Show the shortcuts that would be written without writing anything
#[clap(long)]
dry_run: bool,
}
#[derive(Parser)]
pub struct Hotkeys {
#[clap(subcommand)]
command: HotkeysCommand,
}
#[derive(Subcommand)]
enum HotkeysCommand {
/// Plan the bindings of a key binding file, and write those that are static shortcuts as KDE
/// shortcut files
Compile(Compile),
}
#[derive(Parser)]
struct Compile {
/// The key binding file [default: the first of skhdrc, whkdrc and sxhkdrc in the komorebi
/// config directory]
file: Option<PathBuf>,
/// The format of the file [default: from the end of its name: skhdrc, whkdrc or sxhkdrc]
#[clap(short, long, value_enum)]
format: Option<KeyFormat>,
/// Which bindings are static shortcuts: none (engine), every binding a shortcut file can
/// express (auto), or only those, leaving the others out (static)
#[clap(short, long, value_enum, default_value_t = PlanMode::default().into())]
mode: KeyPlanMode,
/// Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
#[clap(short, long)]
output: Option<PathBuf>,
/// Write nothing, and fail, when a diagnostic is a warning or an error: something in the
/// file is not realized the way its own hotkey daemon realizes it
#[clap(long)]
strict: bool,
/// Activate shortcuts that are new straight away, instead of at the next login
#[clap(long)]
reload: bool,
/// Show the shortcuts that would be written without writing anything
#[clap(long)]
dry_run: bool,
}
/// [`Format`], for the command line
#[derive(Clone, Copy, ValueEnum)]
enum KeyFormat {
Skhd,
Whkd,
Sxhkd,
}
impl From<KeyFormat> for Format {
fn from(format: KeyFormat) -> Self {
match format {
KeyFormat::Skhd => Format::Skhd,
KeyFormat::Whkd => Format::Whkd,
KeyFormat::Sxhkd => Format::Sxhkd,
}
}
}
/// [`PlanMode`], for the command line
#[derive(Clone, Copy, ValueEnum)]
enum KeyPlanMode {
Auto,
Engine,
Static,
}
impl From<PlanMode> for KeyPlanMode {
fn from(mode: PlanMode) -> Self {
match mode {
PlanMode::Auto => KeyPlanMode::Auto,
PlanMode::Engine => KeyPlanMode::Engine,
PlanMode::Static => KeyPlanMode::Static,
}
}
}
impl From<KeyPlanMode> for PlanMode {
fn from(mode: KeyPlanMode) -> Self {
match mode {
KeyPlanMode::Auto => PlanMode::Auto,
KeyPlanMode::Engine => PlanMode::Engine,
KeyPlanMode::Static => PlanMode::Static,
}
}
}
/// What to export, and how
struct Export {
file: PathBuf,
format: Format,
mode: PlanMode,
output: Option<PathBuf>,
strict: bool,
reload: bool,
dry_run: bool,
}
/// `komorebic export-kde-shortcuts`: the bindings of an skhdrc that can be KDE shortcut files
pub fn export_kde_shortcuts(args: ExportKdeShortcuts) -> eyre::Result<()> {
export(Export {
file: args.skhdrc.unwrap_or_else(|| HOME_DIR.join("skhdrc")),
format: Format::Skhd,
mode: PlanMode::Static,
output: args.output,
strict: false,
reload: args.reload,
dry_run: args.dry_run,
})
}
/// `komorebic hotkeys`
pub fn hotkeys(args: Hotkeys) -> eyre::Result<()> {
match args.command {
HotkeysCommand::Compile(args) => {
let file = match args.file {
Some(file) => file,
None => find_file(&HOME_DIR)?,
};
let format = match args.format {
Some(format) => format.into(),
None => format_of(&file)?,
};
export(Export {
file,
format,
mode: args.mode.into(),
output: args.output,
strict: args.strict,
reload: args.reload,
dry_run: args.dry_run,
})
}
}
}
const FORMATS: [Format; 3] = [Format::Skhd, Format::Whkd, Format::Sxhkd];
/// The first key binding file of the three formats in `dir`, and its format
fn find(dir: &Path) -> Option<(PathBuf, Format)> {
FORMATS
.into_iter()
.map(|format| (dir.join(format.file_name()), format))
.find(|(path, _)| path.is_file())
}
/// The first key binding file of the three formats in `dir`
fn find_file(dir: &Path) -> eyre::Result<PathBuf> {
find(dir).map(|(path, _)| path).ok_or_else(|| {
eyre::Report::msg(format!(
"there is no skhdrc, whkdrc or sxhkdrc in {}: name the file to read",
dir.display()
))
})
}
/// The format a file's name ends with
fn format_of(file: &Path) -> eyre::Result<Format> {
let name = file
.file_name()
.and_then(|n| n.to_str())
.unwrap_or_default();
FORMATS
.into_iter()
.find(|format| name.ends_with(format.file_name()))
.ok_or_else(|| {
eyre::Report::msg(format!(
"{} does not end with skhdrc, whkdrc or sxhkdrc: give its --format",
file.display()
))
})
}
/// Where the shortcut files go when no directory is given: `kglobalaccel` in the data directory
fn shortcut_dir() -> Option<PathBuf> {
dirs::data_dir().map(|dir| dir.join("kglobalaccel"))
}
/// What reading and planning a file have to say about it, in the order of the file
fn diagnostics<'a>(parsed: &'a Parsed, plan: &'a Plan) -> Vec<&'a Diagnostic> {
let mut diagnostics: Vec<&Diagnostic> =
parsed.diagnostics.iter().chain(&plan.diagnostics).collect();
diagnostics.sort_by_key(|diagnostic| diagnostic.span.start);
diagnostics
}
fn export(export: Export) -> eyre::Result<()> {
let file = &export.file;
let text = std::fs::read_to_string(file).map_err(|error| {
eyre::Report::msg(format!("could not read {}: {error}", file.display()))
})?;
let parsed = komorebi_hotkeys::parse(export.format, &text, &ParseOptions::default());
let plan = komorebi_hotkeys::plan::plan(&parsed.keymap, &PlanOptions { mode: export.mode });
let diagnostics = diagnostics(&parsed, &plan);
for diagnostic in &diagnostics {
eprintln!("{}: {diagnostic}", file.display());
}
if export.strict
&& diagnostics
.iter()
.any(|diagnostic| diagnostic.severity >= Severity::Warning)
{
eyre::bail!(
"{} is not realized as it says (the warnings and errors above), and --strict is set",
file.display()
);
}
for shortcut in &plan.static_files {
println!("{:<24} {}", shortcut.combo.to_string(), shortcut.command);
}
let engine: usize = plan.engine.modes.iter().map(|m| m.bindings.len()).sum();
let files = kde::desktop_files(&plan.static_files);
let output = export
.output
.unwrap_or_else(|| shortcut_dir().expect("there is no data directory"));
if export.dry_run {
let diff = kde::diff(&output, &files)?;
println!(
"{} shortcuts would be written to {} ({} new, {} changed, {} removed), {} bindings need the engine",
files.len(),
output.display(),
diff.added.len(),
diff.changed.len(),
diff.removed.len(),
engine
);
return Ok(());
}
let written = kde::write(&output, &files)?;
println!(
"wrote {} shortcuts to {} ({} new, {} changed, {} removed), {} bindings need the engine",
files.len(),
output.display(),
written.added.len(),
written.changed.len(),
written.removed.len(),
engine
);
// KWin 6.8 runs the global shortcut daemon itself and reads these files when it starts. A
// shortcut it has not met can be handed over now; one it already runs keeps what it loaded
// until the next login.
if export.reload {
for name in written.added.iter().chain(&written.unchanged) {
let registered = Command::new("busctl")
.args([
"--user",
"call",
"org.kde.kglobalaccel",
"/kglobalaccel",
"org.kde.KGlobalAccel",
"doRegister",
"as",
"4",
name,
"_launch",
"",
"",
])
.stdout(Stdio::null())
.status()
.is_ok_and(|status| status.success());
if !registered {
eyre::bail!("could not register {name} with KWin: is this a Plasma session?");
}
}
println!(
"{} shortcuts are active now",
written.added.len() + written.unchanged.len()
);
if !(written.changed.is_empty() && written.removed.is_empty()) {
println!(
"{} changed and {} removed ones take effect at your next login",
written.changed.len(),
written.removed.len()
);
}
} else if !files.is_empty() || !written.removed.is_empty() {
println!("they take effect at your next login; --reload activates new ones straight away");
}
Ok(())
}
/// `n` and the noun, in the singular when there is one
fn count(n: usize, singular: &str, plural: &str) -> String {
format!("{n} {}", if n == 1 { singular } else { plural })
}
/// The first five diagnostics of a kind, one to a line, for the hint of a finding
fn lines(diagnostics: &[&Diagnostic], severity: Severity) -> (usize, String) {
let of_kind: Vec<String> = diagnostics
.iter()
.filter(|diagnostic| diagnostic.severity == severity)
.map(|diagnostic| diagnostic.to_string())
.collect();
(
of_kind.len(),
of_kind.into_iter().take(5).collect::<Vec<_>>().join("\n"),
)
}
/// The key bindings, for `komorebic check`: the file `hotkeys compile` would read, what reading
/// and planning it have to say, and whether the shortcut files there are the ones it would write
/// for it.
pub fn check(home: &Path) -> Vec<Finding> {
check_in(home, shortcut_dir().as_deref(), PlanMode::default())
}
/// [`check`], for the key binding file in `home`, planned in `mode`, against the shortcut files in
/// `shortcuts`
fn check_in(home: &Path, shortcuts: Option<&Path>, mode: PlanMode) -> Vec<Finding> {
let Some((file, format)) = find(home) else {
return vec![
Finding::note(format!(
"there is no skhdrc, whkdrc or sxhkdrc in {}",
home.display()
))
.hint(
"key bindings are KDE global shortcuts: they come from a key binding file through `komorebic hotkeys compile`, or are set up in System Settings",
),
];
};
let text = match std::fs::read_to_string(&file) {
Ok(text) => text,
Err(error) => {
return vec![Finding::warning(format!(
"could not read {}: {error}",
file.display()
))];
}
};
let parsed = komorebi_hotkeys::parse(format, &text, &ParseOptions::default());
let plan = komorebi_hotkeys::plan::plan(&parsed.keymap, &PlanOptions { mode });
let diagnostics = diagnostics(&parsed, &plan);
let bindings: usize = parsed.keymap.modes.iter().map(|m| m.bindings.len()).sum();
let engine: usize = plan.engine.modes.iter().map(|m| m.bindings.len()).sum();
let mut findings = vec![Finding::ok(format!(
"{} has {}: {} as shortcut files, {} in the engine",
file.display(),
count(bindings, "key binding", "key bindings"),
plan.static_files.len(),
engine
))];
let (errors, shown) = lines(&diagnostics, Severity::Error);
if errors > 0 {
findings.push(
Finding::warning(format!(
"{} of it cannot be read and left out",
count(errors, "line", "lines")
))
.hint(shown),
);
}
let (warnings, shown) = lines(&diagnostics, Severity::Warning);
if warnings > 0 {
findings.push(
Finding::note(format!(
"{} not realized as {} would",
count(warnings, "binding is", "bindings are"),
format.file_name().trim_end_matches("rc")
))
.hint(shown),
);
}
let files = kde::desktop_files(&plan.static_files);
match shortcuts.map(|dir| kde::diff(dir, &files)) {
Some(Ok(diff)) if diff.added.is_empty() && diff.changed.is_empty() && diff.removed.is_empty() => {
findings.push(Finding::ok(if files.is_empty() {
"no shortcut files are needed, and komorebi has written none"
} else {
"the shortcut files are the ones `komorebic hotkeys compile` writes"
}));
}
Some(Ok(diff)) => findings.push(
Finding::warning(format!(
"the shortcut files are not the ones `komorebic hotkeys compile` would write: {} to add, {} to change, {} to remove",
diff.added.len(),
diff.changed.len(),
diff.removed.len()
))
.hint("`komorebic hotkeys compile --reload`"),
),
Some(Err(error)) => findings.push(Finding::warning(format!(
"could not look at the shortcut files: {error}"
))),
None => {}
}
findings
}
#[cfg(test)]
mod tests {
use super::*;
use komorebi_client::check::Level;
/// A directory of its own, removed when it goes out of scope
struct Scratch(PathBuf);
impl Scratch {
fn new() -> Self {
static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
let dir = std::env::temp_dir().join(format!(
"komorebic-hotkeys-unit-{}-{}",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
Self(dir)
}
fn file(&self, name: &str, text: &str) -> &Self {
std::fs::write(self.0.join(name), text).unwrap();
self
}
fn shortcuts(&self) -> PathBuf {
self.0.join("shortcuts")
}
}
impl Drop for Scratch {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
const SKHDRC: &str = "alt - h : komorebic focus left\nalt - l : komorebic focus right\n";
/// The level and message of each finding
fn said(findings: &[Finding]) -> Vec<(Level, String)> {
findings
.iter()
.map(|finding| (finding.level, finding.message.clone()))
.collect()
}
#[test]
fn without_a_key_binding_file_there_is_a_note_that_says_where_they_come_from() {
let home = Scratch::new();
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
assert_eq!(findings.len(), 1);
assert_eq!(findings[0].level, Level::Note);
assert!(
findings[0]
.message
.starts_with("there is no skhdrc, whkdrc or sxhkdrc in")
);
assert!(
findings[0]
.hint
.as_deref()
.is_some_and(|hint| hint.contains("komorebic hotkeys compile"))
);
}
#[test]
fn the_first_file_of_the_three_formats_is_the_one_that_is_read() {
let home = Scratch::new();
home.file("sxhkdrc", "super + h\n komorebic focus left\n")
.file(
"whkdrc",
"alt + h : komorebic focus left\nalt + l : komorebic focus right\n",
);
let findings = check_in(&home.0, None, PlanMode::Engine);
assert_eq!(findings[0].level, Level::Ok);
assert!(
findings[0]
.message
.ends_with("whkdrc has 2 key bindings: 0 as shortcut files, 2 in the engine"),
"{}",
findings[0].message
);
}
#[test]
fn the_bindings_are_counted_by_where_the_plan_puts_them() {
let home = Scratch::new();
home.file(
"sxhkdrc",
"super + h\n komorebic focus left\nsuper + l\n komorebic focus right\nsuper + w ; h\n komorebic move left\n",
);
let auto = check_in(&home.0, None, PlanMode::Auto);
let engine = check_in(&home.0, None, PlanMode::Engine);
assert!(
auto[0]
.message
.ends_with("has 3 key bindings: 2 as shortcut files, 1 in the engine"),
"{}",
auto[0].message
);
assert!(
engine[0]
.message
.ends_with("has 3 key bindings: 0 as shortcut files, 3 in the engine"),
"{}",
engine[0].message
);
}
#[test]
fn one_binding_is_not_plural() {
let home = Scratch::new();
home.file("skhdrc", "alt - h : komorebic focus left\n");
let findings = check_in(&home.0, None, PlanMode::Auto);
assert!(
findings[0]
.message
.ends_with("has 1 key binding: 1 as shortcut files, 0 in the engine"),
"{}",
findings[0].message
);
}
#[test]
fn shortcut_files_that_are_the_ones_of_the_plan_are_ok() {
let home = Scratch::new();
home.file("skhdrc", SKHDRC);
let parsed = komorebi_hotkeys::parse(Format::Skhd, SKHDRC, &ParseOptions::default());
let plan = komorebi_hotkeys::plan::plan(
&parsed.keymap,
&PlanOptions {
mode: PlanMode::Auto,
},
);
kde::write(&home.shortcuts(), &kde::desktop_files(&plan.static_files)).unwrap();
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
assert_eq!(
said(&findings)[1],
(
Level::Ok,
"the shortcut files are the ones `komorebic hotkeys compile` writes".to_string()
)
);
}
#[test]
fn shortcut_files_that_are_not_the_ones_of_the_plan_are_a_warning_that_says_how_many() {
let home = Scratch::new();
home.file("skhdrc", SKHDRC);
let old = "alt - h : komorebic focus left\nalt - x : komorebic focus down\n";
let parsed = komorebi_hotkeys::parse(Format::Skhd, old, &ParseOptions::default());
let plan = komorebi_hotkeys::plan::plan(
&parsed.keymap,
&PlanOptions {
mode: PlanMode::Auto,
},
);
kde::write(&home.shortcuts(), &kde::desktop_files(&plan.static_files)).unwrap();
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
assert_eq!(findings[1].level, Level::Warning);
assert_eq!(
findings[1].message,
"the shortcut files are not the ones `komorebic hotkeys compile` would write: 1 to add, 0 to change, 1 to remove"
);
assert_eq!(
findings[1].hint.as_deref(),
Some("`komorebic hotkeys compile --reload`")
);
}
#[test]
fn a_file_that_needs_no_shortcut_files_and_a_directory_without_any_agree() {
let home = Scratch::new();
home.file("skhdrc", SKHDRC);
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Engine);
assert_eq!(
said(&findings)[1],
(
Level::Ok,
"no shortcut files are needed, and komorebi has written none".to_string()
)
);
}
#[test]
fn a_line_that_cannot_be_read_is_a_warning_that_shows_the_line() {
let home = Scratch::new();
home.file(
"skhdrc",
"alt - h : komorebic focus left\nalt - nosuchkey : komorebic focus up\n",
);
let findings = check_in(&home.0, None, PlanMode::Auto);
assert_eq!(findings[1].level, Level::Warning);
assert_eq!(
findings[1].message,
"1 line of it cannot be read and left out"
);
assert!(
findings[1]
.hint
.as_deref()
.is_some_and(|hint| hint.starts_with("line 2: error: ")),
"{:?}",
findings[1].hint
);
}
#[test]
fn a_binding_that_is_not_realized_as_its_own_daemon_would_is_a_note() {
let home = Scratch::new();
home.file("skhdrc", "lalt - j : komorebic focus down\n");
let findings = check_in(&home.0, None, PlanMode::Auto);
assert_eq!(findings[1].level, Level::Note);
assert_eq!(
findings[1].message,
"1 binding is not realized as skhd would"
);
assert!(
findings[1]
.hint
.as_deref()
.is_some_and(|hint| hint.starts_with("line 1: warning: ")),
"{:?}",
findings[1].hint
);
}
#[test]
fn a_hint_shows_five_lines_at_most() {
let home = Scratch::new();
let text: String = (0..8)
.map(|n| format!("lalt - {} : x\n", (b'a' + n) as char))
.collect();
home.file("skhdrc", &text);
let findings = check_in(&home.0, None, PlanMode::Auto);
assert_eq!(
findings[1].message,
"8 bindings are not realized as skhd would"
);
assert_eq!(findings[1].hint.as_deref().unwrap().lines().count(), 5);
}
}
+32 -13
View File
@@ -101,17 +101,19 @@
//! The others work without the daemon: `quickstart` writes an example `komorebi.json` and
//! `applications.json` in the config home, `enable-autostart` and `disable-autostart` write and
//! remove the entry that has Plasma start komorebi at login, `start` runs `komorebi` in the
//! background, with the
//! `komorebi.json` it is given with `--config`, `check` reads the `komorebi.json` the daemon would
//! and looks at the desktop, and reports what is wrong, exiting with status 1 if something is an
//! error,
//! `configuration` shows the path of the
//! `komorebi.json` the daemon reads, `log` follows its log, `data-directory` shows where its
//! background, with the `komorebi.json` it is given with `--config`, `check` reads the
//! `komorebi.json` the daemon would and the key binding file, looks at the desktop, and reports
//! what is wrong, exiting with status 1 if something is an error, `configuration` shows the path
//! of the `komorebi.json` the daemon reads, `log` follows its log, `data-directory` shows where its
//! socket is, `completions` prints a completion script for a shell, and `static-config-schema`,
//! `application-specific-configuration-schema`, `notification-schema` and `socket-schema` print
//! the JSON Schema of `komorebi.json`, of an `applications.json`, of a notification and of a
//! message. The hidden `docgen` writes the help of every subcommand as Markdown, wrapped
//! at 100 columns whatever the width of the terminal, which is how `docs/cli` is made.
//!
//! `export-kde-shortcuts` and `hotkeys compile` read a key binding file (an skhdrc, a whkdrc or an
//! sxhkdrc) and write the bindings KDE can run by itself as shortcut files; the [`hotkeys`] module
//! has the details.
use chrono::Utc;
use clap::CommandFactory;
@@ -149,6 +151,8 @@ use std::sync::atomic::Ordering;
use std::time::Duration;
use sysinfo::ProcessesToUpdate;
mod hotkeys;
lazy_static! {
static ref HAS_CUSTOM_CONFIG_HOME: AtomicBool = AtomicBool::new(false);
static ref HOME_DIR: PathBuf = {
@@ -836,7 +840,7 @@ struct Check {
#[clap(action, short, long)]
#[clap(value_parser = replace_env_in_path)]
komorebi_config: Option<PathBuf>,
/// Look at the configuration only, not at the desktop
/// Look at the configuration and the key bindings only, not at the desktop
#[clap(long)]
configuration_only: bool,
}
@@ -863,6 +867,11 @@ enum SubCommand {
Completions(Completions),
/// Gather example configurations for a new-user quickstart
Quickstart,
/// Turn an skhdrc into KDE global shortcuts (they work over RDP, unlike evdev hotkey daemons)
ExportKdeShortcuts(hotkeys::ExportKdeShortcuts),
/// Turn a key binding file (skhdrc, whkdrc, sxhkdrc) into KDE global shortcuts
#[clap(arg_required_else_help = true)]
Hotkeys(hotkeys::Hotkeys),
/// Start komorebi as a background process
Start(Start),
/// Stop the komorebi process
@@ -1367,12 +1376,18 @@ fn main() -> eyre::Result<()> {
for cmd in subcommands {
let name = cmd.get_name().to_string();
if !ignore.contains(&name.as_str()) {
// the same pages whatever the width of the terminal docgen runs in
let help_text = cmd.clone().term_width(100).render_long_help().to_string();
let outpath = output_dir.join(format!("{name}.md"));
let markdown = format!("```text\n{help_text}\n```\n");
std::fs::write(&outpath, markdown)?;
println!("{}", outpath.display());
// a subcommand of a subcommand (`hotkeys compile`) gets a page of its own
let nested = cmd
.get_subcommands()
.map(|sub| (format!("{name}-{}", sub.get_name()), sub.clone()));
for (name, cmd) in std::iter::once((name.clone(), cmd.clone())).chain(nested) {
// the same pages whatever the width of the terminal docgen runs in
let help_text = cmd.term_width(100).render_long_help().to_string();
let outpath = output_dir.join(format!("{name}.md"));
let markdown = format!("```text\n{help_text}\n```\n");
std::fs::write(&outpath, markdown)?;
println!("{}", outpath.display());
}
}
}
}
@@ -1380,6 +1395,8 @@ fn main() -> eyre::Result<()> {
let mut cli = Opts::command();
clap_complete::generate(args.shell, &mut cli, "komorebic", &mut std::io::stdout());
}
SubCommand::ExportKdeShortcuts(args) => hotkeys::export_kde_shortcuts(args)?,
SubCommand::Hotkeys(args) => hotkeys::hotkeys(args)?,
SubCommand::Quickstart => {
fn write_file_with_prompt(
path: &PathBuf,
@@ -1496,6 +1513,8 @@ fn main() -> eyre::Result<()> {
place.extend(findings);
report.push("Configuration", place);
report.push("Key bindings", hotkeys::check(&HOME_DIR));
if !args.configuration_only {
report.push(
"The desktop",
+103
View File
@@ -204,3 +204,106 @@ fn what_starts_komorebi_at_login_is_said_whether_or_not_the_desktop_is_there() {
let _ = std::fs::remove_dir_all(dir);
}
/// Runs `komorebic check --configuration-only` in the config home `dir`, with a data home of its
/// own: the section of the key bindings is the one this looks at.
fn check_keys(dir: &Path) -> (Output, String) {
let output = Command::new(env!("CARGO_BIN_EXE_komorebic"))
.arg("check")
.arg("--configuration-only")
.env("KOMOREBI_CONFIG_HOME", dir)
.env("XDG_DATA_HOME", dir.join("data"))
.output()
.unwrap();
let text = String::from_utf8_lossy(&output.stdout).into_owned();
(output, text)
}
#[test]
fn without_a_key_binding_file_the_section_says_where_key_bindings_come_from() {
let dir = scratch("keys-none");
let (output, text) = check_keys(&dir);
assert!(output.status.success(), "{text}");
assert!(text.contains("Key bindings"), "{text}");
assert!(
text.contains("there is no skhdrc, whkdrc or sxhkdrc in"),
"{text}"
);
assert!(text.contains("komorebic hotkeys compile"), "{text}");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn the_key_binding_file_of_the_config_home_is_read_and_a_line_it_cannot_read_is_a_warning() {
let dir = scratch("keys-file");
std::fs::write(
dir.join("skhdrc"),
"alt - h : komorebic focus left\nalt - nosuchkey : komorebic focus up\n",
)
.unwrap();
let (output, text) = check_keys(&dir);
// a warning is not a reason to fail
assert!(output.status.success(), "{text}");
assert!(text.contains("skhdrc has 1 key binding"), "{text}");
assert!(
text.contains("1 line of it cannot be read and left out"),
"{text}"
);
assert!(text.contains("line 2: error: "), "{text}");
assert!(text.contains("1 warning(s)"), "{text}");
let _ = std::fs::remove_dir_all(dir);
}
// the data home is where `dirs` looks on Linux only
#[cfg(target_os = "linux")]
#[test]
fn shortcut_files_the_file_does_not_call_for_are_a_warning_until_compile_replaces_them() {
let dir = scratch("keys-stale");
std::fs::write(dir.join("skhdrc"), "alt - h : komorebic focus left\n").unwrap();
let shortcuts = dir.join("data/kglobalaccel");
std::fs::create_dir_all(&shortcuts).unwrap();
std::fs::write(
shortcuts.join("komorebi-old.desktop"),
"[Desktop Entry]\nX-Komorebi-Generated=true\n",
)
.unwrap();
let (output, text) = check_keys(&dir);
assert!(output.status.success(), "{text}");
assert!(
text.contains(
"the shortcut files are not the ones `komorebic hotkeys compile` would write"
),
"{text}"
);
assert!(text.contains("1 to remove"), "{text}");
assert!(
text.contains("komorebic hotkeys compile --reload"),
"{text}"
);
let compiled = Command::new(env!("CARGO_BIN_EXE_komorebic"))
.args(["hotkeys", "compile"])
.env("KOMOREBI_CONFIG_HOME", &dir)
.env("XDG_DATA_HOME", dir.join("data"))
.output()
.unwrap();
assert!(compiled.status.success(), "{compiled:?}");
let (_, text) = check_keys(&dir);
assert!(!text.contains("are not the ones"), "{text}");
assert!(
text.contains("the shortcut files are the ones")
|| text.contains("no shortcut files are needed"),
"{text}"
);
let _ = std::fs::remove_dir_all(dir);
}
+3
View File
@@ -1144,6 +1144,7 @@ fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
"enforce-workspace-rules.md",
"ensure-named-workspaces.md",
"ensure-workspaces.md",
"export-kde-shortcuts.md",
"flip-layout.md",
"focus-last-workspace.md",
"focus-monitor-at-cursor.md",
@@ -1159,6 +1160,8 @@ fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
"generate-static-config.md",
"global-state.md",
"global-work-area-offset.md",
"hotkeys-compile.md",
"hotkeys.md",
"ignore-rule.md",
"initial-named-workspace-rule.md",
"initial-workspace-rule.md",
+301
View File
@@ -0,0 +1,301 @@
//! `export-kde-shortcuts` and `hotkeys compile` as a person runs them: the shortcut files they
//! write for a key binding file, what they print, and when they refuse.
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
use std::process::Output;
use std::sync::atomic::AtomicU32;
use std::sync::atomic::Ordering;
/// A directory for one test: a komorebi config directory in `config`, and shortcut files in
/// `shortcuts`
struct Scratch(PathBuf);
impl Scratch {
fn new() -> Self {
static NEXT: AtomicU32 = AtomicU32::new(0);
let dir = std::env::temp_dir().join(format!(
"komorebic-hotkeys-{}-{}",
std::process::id(),
NEXT.fetch_add(1, Ordering::SeqCst)
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("config")).unwrap();
Self(dir)
}
fn config(&self) -> PathBuf {
self.0.join("config")
}
fn shortcuts(&self) -> PathBuf {
self.0.join("shortcuts")
}
/// Writes `text` to the config directory as `name`, and returns its path
fn file(&self, name: &str, text: &str) -> PathBuf {
let path = self.config().join(name);
std::fs::write(&path, text).unwrap();
path
}
fn komorebic(&self, args: &[&str]) -> Output {
Command::new(env!("CARGO_BIN_EXE_komorebic"))
.args(args)
.env("KOMOREBI_CONFIG_HOME", self.config())
.output()
.unwrap()
}
/// The names of the files in the shortcut directory, sorted
fn written(&self) -> Vec<String> {
let Ok(entries) = std::fs::read_dir(self.shortcuts()) else {
return Vec::new();
};
let mut names: Vec<String> = entries
.map(|entry| entry.unwrap().file_name().into_string().unwrap())
.collect();
names.sort();
names
}
}
impl Drop for Scratch {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
fn stdout(output: &Output) -> String {
String::from_utf8_lossy(&output.stdout).into_owned()
}
fn stderr(output: &Output) -> String {
String::from_utf8_lossy(&output.stderr).into_owned()
}
fn fixture(name: &str) -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../komorebi-hotkeys/tests/fixtures")
.join(name)
}
const SKHDRC: &str = "\
alt - h : komorebic focus left
alt - l : komorebic focus right
lalt - j : komorebic focus down
:: resize
alt - r ; resize
resize < h : komorebic resize-axis horizontal decrease
";
#[test]
fn export_kde_shortcuts_writes_a_file_for_each_binding_a_shortcut_can_be() {
let scratch = Scratch::new();
scratch.file("skhdrc", SKHDRC);
let output = scratch.komorebic(&[
"export-kde-shortcuts",
"--output",
scratch.shortcuts().to_str().unwrap(),
]);
assert!(output.status.success(), "{output:?}");
assert_eq!(
scratch.written(),
[
"komorebi-focus-down.desktop",
"komorebi-focus-left.desktop",
"komorebi-focus-right.desktop",
]
);
let left =
std::fs::read_to_string(scratch.shortcuts().join("komorebi-focus-left.desktop")).unwrap();
assert!(left.contains("\nX-KDE-Shortcuts=Alt+H\n"), "{left}");
assert!(left.contains("\nExec=komorebic focus left\n"), "{left}");
assert!(
stdout(&output).starts_with("Alt+H komorebic focus left\n"),
"{output:?}"
);
assert!(
stdout(&output).contains("wrote 3 shortcuts to "),
"{output:?}"
);
// the modes are left out, and lalt is either Alt: the diagnostics say so, with the file
let diagnostics = stderr(&output);
assert!(
diagnostics.contains("skhdrc: line 3: warning: "),
"{diagnostics}"
);
assert!(
diagnostics.contains("skhdrc: line 5: warning: "),
"{diagnostics}"
);
assert!(diagnostics.contains("is left out"), "{diagnostics}");
}
#[test]
fn a_dry_run_writes_nothing_and_says_what_a_write_would_change() {
let scratch = Scratch::new();
let skhdrc = scratch.file("my-bindings", SKHDRC);
let shortcuts = scratch.shortcuts();
std::fs::create_dir_all(&shortcuts).unwrap();
std::fs::write(shortcuts.join("mine.desktop"), "[Desktop Entry]\n").unwrap();
let output = scratch.komorebic(&[
"export-kde-shortcuts",
"--skhdrc",
skhdrc.to_str().unwrap(),
"--output",
shortcuts.to_str().unwrap(),
"--dry-run",
]);
assert!(output.status.success(), "{output:?}");
assert_eq!(scratch.written(), ["mine.desktop"]);
assert!(
stdout(&output).contains("3 shortcuts would be written to "),
"{output:?}"
);
assert!(
stdout(&output).contains("(3 new, 0 changed, 0 removed), 0 bindings need the engine"),
"{output:?}"
);
}
#[test]
fn compile_writes_the_same_shortcut_files_from_each_format() {
let written = |file: &str| {
let scratch = Scratch::new();
let output = scratch.komorebic(&[
"hotkeys",
"compile",
"--mode",
"auto",
fixture(file).to_str().unwrap(),
"--output",
scratch.shortcuts().to_str().unwrap(),
]);
assert!(output.status.success(), "{output:?}");
scratch.written()
};
let skhd = written("sample.skhdrc");
assert_eq!(skhd.len(), 50);
assert_eq!(skhd, written("sample.whkdrc"));
assert_eq!(skhd, written("sample.sxhkdrc"));
}
#[test]
fn compile_without_a_file_reads_the_first_file_of_the_config_directory() {
let scratch = Scratch::new();
scratch.file("whkdrc", ".shell pwsh\nalt + h : komorebic focus left\n");
scratch.file("sxhkdrc", "alt + l\n komorebic focus right\n");
let output = scratch.komorebic(&[
"hotkeys",
"compile",
"--mode",
"static",
"--output",
scratch.shortcuts().to_str().unwrap(),
]);
assert!(output.status.success(), "{output:?}");
// skhdrc, whkdrc, sxhkdrc: the whkdrc is the first that exists
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
}
#[test]
fn compile_in_engine_mode_writes_no_shortcut_and_removes_the_ones_it_wrote() {
let scratch = Scratch::new();
let skhdrc = scratch.file("skhdrc", SKHDRC);
let compile = |mode: &str| {
scratch.komorebic(&[
"hotkeys",
"compile",
"--mode",
mode,
skhdrc.to_str().unwrap(),
"--output",
scratch.shortcuts().to_str().unwrap(),
])
};
assert!(compile("static").status.success());
assert_eq!(scratch.written().len(), 3);
let output = compile("engine");
assert!(output.status.success(), "{output:?}");
assert!(scratch.written().is_empty());
assert!(
stdout(&output).contains("wrote 0 shortcuts to "),
"{output:?}"
);
assert!(
stdout(&output).contains("(0 new, 0 changed, 3 removed), 5 bindings need the engine"),
"{output:?}"
);
}
#[test]
fn strict_refuses_a_file_with_a_warning_and_writes_nothing() {
let scratch = Scratch::new();
let skhdrc = scratch.file("skhdrc", SKHDRC);
let output = scratch.komorebic(&[
"hotkeys",
"compile",
"--strict",
"--mode",
"auto",
skhdrc.to_str().unwrap(),
"--output",
scratch.shortcuts().to_str().unwrap(),
]);
assert!(!output.status.success(), "{output:?}");
assert!(scratch.written().is_empty());
assert!(stderr(&output).contains("--strict is set"), "{output:?}");
let clean = scratch.file("clean-skhdrc", "alt - h : komorebic focus left\n");
let output = scratch.komorebic(&[
"hotkeys",
"compile",
"--strict",
"--mode",
"auto",
clean.to_str().unwrap(),
"--output",
scratch.shortcuts().to_str().unwrap(),
]);
assert!(output.status.success(), "{output:?}");
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
}
#[test]
fn a_file_whose_name_says_no_format_needs_one() {
let scratch = Scratch::new();
let file = scratch.file("bindings.conf", "alt + h\n komorebic focus left\n");
let shortcuts = scratch.shortcuts();
let compile = |extra: &[&str]| {
let mut args = vec!["hotkeys", "compile", "--mode", "static"];
args.extend_from_slice(extra);
args.extend([
file.to_str().unwrap(),
"--output",
shortcuts.to_str().unwrap(),
]);
scratch.komorebic(&args)
};
let output = compile(&[]);
assert!(!output.status.success(), "{output:?}");
assert!(stderr(&output).contains("give its --format"), "{output:?}");
let output = compile(&["--format", "sxhkd"]);
assert!(output.status.success(), "{output:?}");
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
}
+3
View File
@@ -8,6 +8,7 @@ A suite imports what it needs from here:
and the komorebi daemon that runs in it.
* [`Outputs`](komorebi_vm.kde.Outputs) are the session's outputs, which a suite
disables, enables and scales to change the monitors under the daemon.
* [`Keys`](komorebi_vm.keys.Keys) presses keys on the machine's keyboard.
* [`daemon`](komorebi_vm.daemon) reads what the daemon logs about the events it
handles and the frames it asks for.
* [`pixels`](komorebi_vm.pixels) reads a screenshot: the color of a pixel, and
@@ -25,12 +26,14 @@ against a fake machine (the `vm-lib` check does).
from komorebi_vm import daemon, latency, pixels, uinput
from komorebi_vm.checks import Checks
from komorebi_vm.kde import Kde, Outputs, Rect
from komorebi_vm.keys import Keys
from komorebi_vm.machine import Machine
from komorebi_vm.pointer import Pointer
__all__ = [
"Checks",
"Kde",
"Keys",
"Machine",
"Outputs",
"Pointer",
+49
View File
@@ -0,0 +1,49 @@
"""Key presses on the test machine's keyboard, as a person types them."""
from komorebi_vm.machine import Machine
# QEMU names the left Super key `meta_l`; the others are named as KDE writes them
_MODIFIERS = {
"alt": "alt",
"ctrl": "ctrl",
"shift": "shift",
"meta": "meta_l",
"super": "meta_l",
}
class Keys:
"""The keyboard of a test machine.
A key press goes through QEMU's virtual keyboard (`machine.send_key`), so it
reaches the guest's kernel as a key of a real keyboard and KWin sees it as
it sees any other: a global shortcut fires on it, and a key that is not one
goes to the focused window. QEMU holds the keys for 100 ms, less than the
delay before a key repeats.
A combo is written as in KDE, in lower case, with `-` between the keys:
`alt-h`, `meta-shift-j`, `esc`. The key names after the modifiers are
QEMU's (`h`, `1`, `esc`, `ret`, `bracket_left`).
"""
def __init__(self, machine: Machine) -> None:
self.machine = machine
@staticmethod
def qemu(combo: str) -> str:
"""Returns `combo` as QEMU's `sendkey` writes it.
A modifier is any of `alt`, `ctrl`, `shift`, `meta` and `super`; the
last word is the key, which QEMU must know.
"""
*modifiers, key = combo.lower().split("-")
for modifier in modifiers:
if modifier not in _MODIFIERS:
raise ValueError(f"{modifier!r} in {combo!r} is not a modifier")
if not key:
raise ValueError(f"{combo!r} has no key")
return "-".join([*(_MODIFIERS[m] for m in modifiers), key])
def send(self, combo: str) -> None:
"""Presses the keys of `combo` together, and releases them."""
self.machine.send_key(self.qemu(combo))
+4
View File
@@ -34,3 +34,7 @@ class Machine(Protocol):
def screenshot(self, filename: str, /) -> None:
"""Saves a PNG of the machine's display as `filename` in `out_dir`."""
...
def send_key(self, key: str, /) -> None:
"""Presses the keys `key` names together on the machine's keyboard (QEMU's `sendkey`)."""
...
+4
View File
@@ -14,6 +14,7 @@ class FakeMachine:
self.out_dir = out_dir
self.commands: list[str] = []
self.keys: list[str] = []
self.replies: list[tuple[Callable[[str], bool], tuple[int, str]]] = []
def reply(self, contains: str, status: int = 0, output: str = "") -> None:
@@ -27,6 +28,9 @@ class FakeMachine:
return answer
return 0, ""
def send_key(self, key: str, /) -> None:
self.keys.append(key)
def screenshot(self, filename: str, /) -> None:
Image.new("RGB", (4, 4), (10, 20, 30)).save(self.out_dir / f"{filename}.png")
+24
View File
@@ -0,0 +1,24 @@
import pytest
from komorebi_vm import Keys
from .conftest import FakeMachine
def test_a_combo_is_sent_as_qemu_names_it(machine: FakeMachine) -> None:
keys = Keys(machine)
keys.send("alt-h")
keys.send("Meta-Shift-j")
keys.send("super-1")
keys.send("esc")
assert machine.keys == ["alt-h", "meta_l-shift-j", "meta_l-1", "esc"]
def test_a_word_that_is_not_a_modifier_is_refused(machine: FakeMachine) -> None:
with pytest.raises(ValueError, match="'hyper' in 'hyper-h' is not a modifier"):
Keys(machine).send("hyper-h")
with pytest.raises(ValueError, match="has no key"):
Keys(machine).send("alt-")
assert machine.keys == []
+54 -3
View File
@@ -3,9 +3,10 @@
# own, komorebi without its script in KWin, komorebi not running, no KWin on the bus. What only a
# real KWin can tell: that its version is read from what KWin says of itself, that the effects are
# komorebi's builds because of what they contain, that a daemon is told from its script by KWin's
# own answer, and that a bus with no KWin on it is an error with an exit status that says so. The
# configuration and the exit status are covered by `komorebi/src/check.rs` and
# `komorebic/tests/check.rs`, against no desktop.
# own answer, that a bus with no KWin on it is an error with an exit status that says so, and that
# the shortcut files the check compares with are in the directory `komorebic hotkeys compile`
# writes to in a session. The configuration and the exit status are covered by
# `komorebi/src/check.rs` and `komorebic/tests/check.rs`, against no desktop.
import base64
import json
import re
@@ -166,5 +167,55 @@ checks.check(
and "komorebi is not running" not in out,
)
print("== 6. the key bindings")
KEYS_HOME = "/tmp/check-keys-home"
SHORTCUTS = "~/.local/share/kglobalaccel"
STALE = "[Desktop Entry]\nX-Komorebi-Generated=true\n"
def check_keys() -> tuple[int, str]:
"""Runs `komorebic check` on the key bindings alone, in a config home of their own."""
status, out = kde.run(f"KOMOREBI_CONFIG_HOME={KEYS_HOME} komorebic check --configuration-only")
print(out)
return status, out
kde.sh(f"mkdir -p {KEYS_HOME}")
status, out = check_keys()
checks.check(
"without a key binding file it is a note, not an error",
status == 0 and re.search(r"note +there is no skhdrc, whkdrc or sxhkdrc in ", out) is not None,
)
kde.sh(
"printf %s "
+ shlex.quote("alt - h : komorebic focus left\nalt - nosuchkey : komorebic focus up\n")
+ f" > {KEYS_HOME}/skhdrc"
)
status, out = check_keys()
checks.check(
"the file is read, and the line it cannot read is a warning that does not fail the check",
status == 0
and "skhdrc has 1 key binding" in out
and re.search(r"warning +1 line of it cannot be read and left out", out) is not None,
)
# a shortcut file komorebi wrote that the file does not call for, in the directory of the session
kde.sh(
f"mkdir -p {SHORTCUTS} && printf %s {shlex.quote(STALE)} > {SHORTCUTS}/komorebi-stale.desktop"
)
status, out = check_keys()
checks.check(
"it says the shortcut files are not the ones `hotkeys compile` would write",
status == 0
and "the shortcut files are not the ones `komorebic hotkeys compile` would write" in out,
)
kde.sh(f"KOMOREBI_CONFIG_HOME={KEYS_HOME} komorebic hotkeys compile")
status, out = check_keys()
checks.check(
"after `hotkeys compile` it does not: both use the directory of the session",
status == 0 and "are not the ones" not in out,
)
kde.stop()
checks.finish()
@@ -0,0 +1,21 @@
{
tier = "slow";
kind = "session";
timeoutMinutes = 10;
node =
{ config, pkgs, ... }:
{
# static shortcuts work with no komorebi process, and this test runs none
services.komorebi.enable = false;
# The shortcut files of keys.skhdrc, as `komorebic hotkeys compile` writes them, in the system
# profile, where KWin finds them when the session starts
environment.systemPackages = [
config.services.komorebi.package
(pkgs.runCommand "komorebi-keys-static" { } ''
${config.services.komorebi.package}/bin/komorebic hotkeys compile --mode auto \
${./keys.skhdrc} --output $out/share/kglobalaccel
'')
];
};
}
@@ -0,0 +1,5 @@
# vm-keys-static: shortcut files in the system profile, each leaving a file behind when it runs
alt - j : touch /tmp/keys-static-alt-j
alt + shift - k : echo pressed >> /tmp/keys-static-alt-shift-k
# a % is a field code in a desktop entry's Exec line: the shortcut file writes it as %%
alt - p : date +%s > /tmp/keys-static-alt-p
+49
View File
@@ -0,0 +1,49 @@
# Static shortcuts in a real Plasma session: what `komorebic hotkeys compile` and
# `komorebic export-kde-shortcuts` write is run by KWin itself, with no komorebi
# process. The Rust tests check the files; only a KWin can say that it reads them
# and runs their commands on a key: the files in the system profile when the
# session starts, and a file written later once `--reload` has handed it over.
from komorebi_vm import Checks, Kde, Keys
start_all()
machine.wait_for_unit("multi-user.target")
checks = Checks()
kde = Kde.session(machine, scale=SCALE)
keys = Keys(machine)
def ran(marker: str) -> bool:
return machine.execute(f"test -e /tmp/{marker}")[0] == 0
def press(combo: str, marker: str) -> bool:
keys.send(combo)
return kde.wait_for(lambda: ran(marker), timeout=10)
print(kde.sh("ls /run/current-system/sw/share/kglobalaccel"))
checks.check("Alt+J runs its command", press("alt-j", "keys-static-alt-j"))
checks.check(
"Alt+Shift+K runs a command that needs a shell",
press("alt-shift-k", "keys-static-alt-shift-k"),
)
checks.check("Alt+P runs a command with a %", press("alt-p", "keys-static-alt-p"))
date = machine.succeed("cat /tmp/keys-static-alt-p").strip()
checks.check(f"the % reached the command as one % ({date!r})", date.isdigit())
# a binding written in the middle of the session, into the user's directory
kde.sh("mkdir -p ~/.config/komorebi")
kde.sh("echo 'alt - u : touch /tmp/keys-static-alt-u' > ~/.config/komorebi/skhdrc")
print(kde.sh("komorebic export-kde-shortcuts --reload"))
written = "/home/komorebi/.local/share/kglobalaccel/komorebi-touch-tmp-keys-static-alt-u.desktop"
checks.check(
"the file is in the user's kglobalaccel directory",
machine.execute(f"test -e {written}")[0] == 0,
)
checks.check(
"Alt+U runs its command once --reload has handed it over",
press("alt-u", "keys-static-alt-u"),
)
checks.finish()