chore(repo): combine the extra shared commands, the macOS wm2 batch and the final docs (candidate 9 draft)

Candidate 9 (draft): wip-u-cmd2 (router gate_message hook + 12 more arms through komorebi_core::command; stacked on wip-u-wm2) with wip-u-mac-wm2 (shared push_simple_rule, macOS ignore-rule fix, Minimize/Close/DebugWindow methods) and wip-u-docs2 (MIGRATION-SUMMARY.md, macos-hand-check-plan.md), all on wip-cand8. Conflicts, if any, are resolved here.
This commit is contained in:
LGUG2Z committed 2026-11-05 15:03:27 -08:00
7 files changed
+637 -123

No files matched your search

+39
View File
@@ -94,6 +94,23 @@ impl From<IdWithIdentifierAndComment> for IdWithIdentifier {
}
}
/// Adds a simple rule that matches `id` as a `kind` (with the legacy matching strategy), unless a
/// simple rule of that kind and id is there already. A rule of another kind with the same id, or a
/// composite rule, does not stop it.
pub fn push_simple_rule(rules: &mut Vec<MatchingRule>, kind: ApplicationIdentifier, id: &str) {
let exists = rules
.iter()
.any(|r| matches!(r, MatchingRule::Simple(r) if r.kind == kind && r.id.eq(id)));
if !exists {
rules.push(MatchingRule::Simple(IdWithIdentifier {
kind,
id: id.to_string(),
matching_strategy: Option::from(MatchingStrategy::Legacy),
}));
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -158,4 +175,26 @@ mod tests {
assert_eq!(plain.id, "/usr/bin/kcalc");
assert_eq!(plain.matching_strategy, None);
}
#[test]
fn push_simple_rule_keeps_rules_of_another_kind_with_the_same_id() {
let mut rules = vec![];
push_simple_rule(&mut rules, ApplicationIdentifier::Class, "foo");
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
assert_eq!(rules.len(), 2);
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
push_simple_rule(&mut rules, ApplicationIdentifier::Class, "foo");
assert_eq!(rules.len(), 2);
rules.clear();
rules.push(MatchingRule::Composite(vec![IdWithIdentifier {
kind: ApplicationIdentifier::Exe,
id: "foo".to_string(),
matching_strategy: None,
}]));
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
assert_eq!(rules.len(), 2);
}
}
+182
View File
@@ -0,0 +1,182 @@
# The consolidation of komorebi, komorebi-for-kde and komorebi-for-mac: final-state summary
Status (written at wip-cand8, b6f4c2ae, 2026-10-31): a summary for a maintainer who was not there.
Gates for candidate 8 were still running when this was written; the results stated below are the ones
that had finished, with the candidate they ran on. Companion documents: [ARCHITECTURE-UNIFIED.md](ARCHITECTURE-UNIFIED.md)
(the map), [build-and-test.md](build-and-test.md) (commands, flakes), [macos-hand-check-plan.md](macos-hand-check-plan.md)
(what the owner must run on a Mac), [known-issues.md](known-issues.md) (open decisions).
## 1. What the repository is now
Three programs (Windows, KDE Plasma, macOS) were three repositories with copies of the same ideas. They are
one repository with one Cargo workspace (one `Cargo.lock`), shared crates under `crates/`, and one package
per user-facing program, the platform chosen by `cfg(target_os)`.
| Package (binary) | Directory | How the platform is chosen |
|---|---|---|
| `komorebi` | `komorebi-daemon/` | `main.rs` is a `cfg_select!` calling `daemon::run()` of `komorebi-windows`, `komorebi-linux` or `komorebi-macos`, which are target-gated dependencies |
| `komorebic` | `komorebic/` | `src/windows.rs`, `src/linux/`, `src/macos/`; the arguments are in `crates/komorebic-core` |
| `komorebi-client` | `komorebi-client/` | `src/{windows,linux,macos}.rs` behind one `Connection` |
| `komorebi-bar` | `komorebi-bar/` | `src/windows/`, `src/macos/`; shared part in `crates/komorebi-bar-core`. KDE has no bar |
Three platform trees remain, because the platform layers are different code: the repository root (Windows:
`komorebi/` is the library `komorebi-windows`), `komorebi-for-kde/` (`komorebi-linux`, hotkeys, NixOS module,
the VM suites) and `komorebi-for-mac/` (`komorebi-macos`, nix-darwin module). The daemon libraries have no
binary; the `komorebi` package is the binary. The crate map and the tree layout are in
[ARCHITECTURE-UNIFIED.md](ARCHITECTURE-UNIFIED.md); how to build each is in [build-and-test.md](build-and-test.md).
## 2. What was shared, and how
| Crate | What it holds | How it was moved |
|---|---|---|
| `komorebi-collections` | `Ring`, `LockableSequence` | the KDE copy was canonical; Windows and macOS switched to it |
| `komorebi-protocol` | `SocketMessage`, payloads, state types | one enum for all platforms (guard arms for platform-only messages); the wire format is pinned by per-platform goldens generated from the three daemons before the move |
| `komorebi-config` | `StaticConfig` and the `komorebi.json` types, schema generation, and the **one window-rule matcher** (`komorebi_config::rules`: `should_act`, `should_act_individual`; see [rule-matching.md](rule-matching.md)) | one union type with per-platform schema views; the matcher replaced three copies, each daemon keeps a thin wrapper with its own signature |
| `komorebi-transport` | the command listener, pause filter, subscriber registry, `EventChannel` | the daemons take the window manager lock; the crate does not name a mutex |
| `komorebi-backend` | the `Backend` trait (what a daemon asks of its platform), plain-data infos, `FakeBackend`, contract tests, the id `Registry` | derived from the evidence in [seam.md](seam.md); Windows goes through it for the clusters in [backend-switch.md](backend-switch.md); KDE runs on it; macOS has an adapter the daemon does not use yet |
| `komorebi-core` | the model, generic over the platform window: `Container<W>`, `Workspace<P>` (with `update_shared`, a skeleton with hooks), `Monitor<P>`, `WorkspaceGlobals`, and `command` (the shared commands over a `CommandHost`: workspace navigation, moves across workspaces and monitors, lock and unlock, focus-workspace with the pointer preamble) | converge in place, then pure move, then converge per daemon; hooks (`WorkspacePlatform`, `MonitorPlatform`, `HideSpot`) carry what differs; details in [core-model.md](core-model.md) |
| `komorebi-settings` | the run-time settings as one immutable snapshot replaced as a whole, instead of process-wide statics (paddings, aspect ratio, layout defaults, display preferences, animation, transparency, window-handling behaviour) | see [settings.md](settings.md) |
| `komorebi-bar-core` | bar configuration, widgets, platform seam, schema views | [bar-unification.md](bar-unification.md) |
| `komorebic-core` | the command line of every platform (clap definitions, docgen), platform enums | the generated `docs/cli` pages were the oracle |
The state JSON each daemon prints is unchanged by the shared `Monitor<P>`/`Workspace<P>` (platform extras are
flattened in, pinned by tests). Native tests of the shared code run on Linux and protect all three daemons
([e2e-to-unit.md](e2e-to-unit.md) says which e2e checks became native).
## 3. What intentionally stays per platform, and why
- **The window manager, the command router and event processing.** About 26-37% of the text is shared and the
rest is real behaviour (Win32 cloaking, rule engines with different lists, KWin desktops, AppKit
accessibility). `WindowManager<P>` is not built: [core-model.md](core-model.md) sections 17, 18, 20 and 24 list the
blockers per platform; section 21 documents the commands that were shared; section 23 is a design note for a
common event vocabulary ("thin events"), not implemented.
- **macOS `Workspace::update`.** It differs in a scrolling early return and a wider SkyLight disable/re-enable
batch; adopting `update_shared` would change scrolling on macOS and cannot be verified without a Mac
(section 22; decision D15 below).
- **Backends and subsystems**: borders, animations, DWM ghosts, KWin bridge and effects, AppKit observers,
wallpapers, hotkeys. The trait is the seam; the rules are in [seam.md](seam.md).
- **The bar's rendering code** (frame margins, `network.rs`, the window seams in `bar.rs`/`main.rs`): step B4 of
[bar-unification.md](bar-unification.md) was not done because it cannot be shown mechanical without a screen.
- **Command line**: each platform keeps its own commands and help text; most are common.
- **Packaging**: [unified-binaries.md](unified-binaries.md): one binary, a library per OS.
## 4. How it was verified
### Oracles (checked in files, compared byte for byte)
Wire goldens (`komorebi-protocol`), the three `schema.json` and `schema.asc.json`, the two `schema.bar.json`
(size and hash pinned in `komorebi-bar-core`), the `docs/cli` pages of each tree, JSON pins of `Container`,
`Monitor` and the state of the three daemons from real fixtures, and derivation drift (`nix eval ...drvPath`).
Details in [ARCHITECTURE-UNIFIED.md](ARCHITECTURE-UNIFIED.md) section 5.
### Gates, by candidate
Each candidate was a merge of the finished stacks, gated once. Results as recorded (host load and flakes noted
in [build-and-test.md](build-and-test.md) section 6):
| Candidate | Windows e2e (QEMU guest) | KDE VM | macOS (a Mac Mini: compile, unit tests, nix) | nix pre-landing |
|---|---|---|---|---|
| baseline (before the work) | stale markers (4 checks) fail; `commands` fails about 1 in 10 sweeps | `vm-commands` never green; `vm-core-e2e` once | n/a | n/a |
| 5 (core: Container, Workspace, Monitor, `update_shared`, settings) | 38 scenarios: green apart from the 4 stale markers and flakes (`commands` 265/1 and `config_reload` 7/1 from a lock-hold stall, `resize` 25/1); the `bar` scenario could not open a window (guest has no OpenGL 2.0), schema byte-equal | 16 of 16 fast suites green, `vm-commands` green for the first time | cargo unit tests and clippy green; nix: packages and module checks green after toolchain and source-filter fixes | n/a |
| 7 (shared rule matcher, shared commands, stall fixes) | not run as a whole | not run | cargo green, nix green | Windows clippy green; Windows fmt and deny, and two KDE clippy lints, failed and were fixed in 8; packages built |
| 8 (pointer picks the monitor, bar wgpu fallback, macOS deep dedup, formatting) | in progress at the time of writing: `commands` 266/0 (first fully clean), `config_reload` 8/0 | queued | nix all green, cargo 665 passed, 0 failed, 1 ignored | in progress |
Stress runs of lock-heavy command sequences compared baseline and candidate 5: non-answers of `komorebic state`
fell from 80-83% to 14-15%, and "border manager stuck" warnings from 21-31 to 3-5 (the stall fixes work; the
stall itself still occurs now and then).
### Flake registry (summary; full table in build-and-test.md)
Known: Windows `commands` stall (about 1 in 10-12 sweeps, cause not found), `lifecycle_hidden`, `resize`, four
stale known-failure markers (`maximizing.user`, `placement` integer case, `unknown_monitor` x2, same on baseline),
a runner quirk for `focus_follows_mouse`. Candidates: daemon start failing with `AllowSetForegroundWindow` at high
load, `hotplug` with the recorder. KDE: `vm-commands` and `vm-core-e2e` were load-dependent on the old baseline.
## 5. What is NOT verified
- **macOS has never run as a daemon in these builds.** Only compile, clippy, unit tests and nix builds ran on a
Mac. Every behaviour change that touches macOS (hiding, the registry, the shared Container API, settings,
pointer-picks-monitor, bar clicks) is listed in [macos-hand-check-plan.md](macos-hand-check-plan.md).
- **The bar at run time.** The Windows `bar` scenario passes schema and config checks; the guest has only
software rendering, so window checks depend on the new wgpu fallback (WARP), which had not run in a guest when
this was written. The macOS bar never rendered under these changes.
- **The KDE `slow` VM tier** (18 suites: keys, rdp, drag and live resize, lock-sleep, wallpaper, look, ...) was not
run; only the `fast` tier (16 suites) was, on candidate 5. Candidate 8 had not been run on the VM yet.
- Windows: no scenario covers transparency or animation; only `config_reload` touches the settings path.
- Behaviour changes marked BEHAVIOUR in revision bodies are landed only after the e2e or VM gate named in the body.
## 6. Known issues
From [known-issues.md](known-issues.md): (1) KDE skipped the pointer-monitor preamble for three workspace
commands, now resolved for all platforms by owner decision; (2) `Monitor::focus_workspace` overwrites a workspace
name; (3) `Workspace::remove_container` focuses the container next to the focused one rather than the removed
one; (4) a subscriber that stops reading can stall the daemon on macOS (a 1 s write timeout was tried and reverted
because it can truncate a notification). Items 2-4 are inherited behaviour, pinned by tests, left for a decision.
Other open items: the Windows lock-hold stall; `komorebi-for-kde/justfile` recipes assume a KDE-only workspace;
`docs/dev/COMPARE.md` and `scripts/compare-gen.py` are stale.
## 7. Cutover list (not done)
What must be deleted or merged to finish; nothing below was changed.
| Item | State | Action |
|---|---|---|
| shim packages | `komorebic-linux`, `komorebic-macos`, `komorebi-client-linux`, `komorebi-client-macos`, `komorebi-bar-macos` are `#[path]` includes of the unified modules | delete them and their directories under `komorebi-for-kde/` and `komorebi-for-mac/`; update the flakes and justfiles that name them |
| version crates | `version-linux`, `version-macos` | one `version` crate; one workspace version (Windows 0.1.42, KDE 0.1.0, macOS 0.1.1 today) |
| flakes | three flakes; the root one imports the other two as `kfde-*` and `kfm-*` | one flake with the platform trees moved to final directories; KDE's VM suites and module, macOS's darwin module stay as outputs |
| `deny.toml`, `rustfmt.toml`, toolchain files | one per tree | one of each |
| workflows | root: `windows.yaml`, `feature-check.yaml`; KDE: `ci.yaml` (nix checks, VM tiers, canary, release), `update-flake-lock.yaml`, `rerun-no-kvm.yaml`; macOS: `nix.yaml`, `release.yaml` (Homebrew formula) | a proposal, not decided: one CI that builds the three packages, runs `crates/` natively, the nix checks, the Windows e2e on a host with KVM, and the KDE VM tiers as today; one release workflow producing the Windows, Linux and macOS artifacts with one tag and one version |
| docs | per-tree `docs/`, CONTRIBUTING, READMEs | one docs tree; `docs/cli` per platform stays until commands are merged; retire COMPARE.md |
| justfiles | three | one |
| tools | `tools/` is committed (fast-check, format-all, kde-closure-check, e2e-needed, gate-lock, ...); see `tools/README.md` | keep; delete the per-tree copies of what they replace |
## 8. How to continue
1. **Get the macOS pass done first.** [macos-hand-check-plan.md](macos-hand-check-plan.md). Nothing deeper should land
on macOS before it.
2. **`WindowManager<P>`.** Blockers per platform: [core-model.md](core-model.md) sections 20 (KDE, macOS) and 24
(Windows). The unmanaged-window gate is not behaviour-neutral to move into the router (a `gate_message` hook is
proposed in section 22.1). Rule: gate every step with the e2e/VM suites, one daemon at a time.
3. **Thin events.** Design note in section 23 (`CoreEvent<W>`, shared handlers for gone, appeared and minimized);
risks: side-effect order per arm, macOS focus change carries no window.
4. **Commands.** `komorebi_core::command` is partial: sixteen arms and focus-workspace are shared; the remaining
arms are per platform (section 21 lists what stays and why). **The rule matcher is done** (one implementation).
5. **The deeper-dedup boundary.** Share a function only when a native test can pin it; where the text differs for
a real platform reason, put the difference behind a hook (as `HideSpot` and `begin_pass` do) rather than
converging behaviour you cannot verify.
6. **Decide items 2-4 of the known issues**, then move them into the shared code with the e2e gate.
7. **Complete the cutover** (section 7), then regenerate the Windows `docs/cli` and the schema docs.
## 9. The decisions that shaped the design
Rewritten from the decisions log. "Owner" marks a decision the owner made; the others were made to unblock and are
reversible as stated.
| # | Decision | Why | Reverse |
|---|---|---|---|
| 1 | One workspace, one `Cargo.lock`; flakes re-export the nested ones and the root builds them from the whole repo | a spike showed 859 to 900 packages with no conflicts; the root source can then be shared | keep three workspaces |
| 2 | macOS checks on Linux use a fake C compiler and only type-check | nothing else runs without a Mac | none |
| 3 | The wire oracle is a schema-driven golden generator run on the three daemons before the move | the move must not change what is sent | none |
| 4 | One union `StaticConfig` with per-platform schema views; per-platform defaults documented in a table instead of converging every doc | users' files must keep loading; schemas are checked in | one type per platform |
| 5 | `komorebic-core` generic over the platform, no `cfg` in the definitions; the CLI docs of each tree are the oracle | the pages are what users read | per-platform clap structs |
| 6 | Shared transport: the daemon locks the window manager, the crate never names a mutex | different locks per daemon | none |
| 7 | The bar is `komorebi-bar-core` plus a platform trait, one config enum, schema = per-platform views of one union; macOS accepts and skips Windows-only keys with a warning | one config file works everywhere | separate bars |
| 8 | `Backend` is derived from evidence (seam.md), not written from memory of one platform | a trait written from one platform bakes in its assumptions | none |
| 9 | Settings handle is `RwLock<Arc<Settings<P>>>` with a writer mutex; the platform part is a type parameter | no new dependency; one consistent snapshot per use | use `ArcSwap` |
| 10 | Unified layout: one package each for `komorebic`, `komorebi-bar`, `komorebi-client`; the daemon as three OS-gated libraries behind one thin binary | rewriting about 1700 `crate::` paths and moving KDE tests was the alternative | merge the libraries later |
| 11 | Shared `Monitor<P>` keeps each daemon's state JSON (flattened platform extras); the runtime `required` order in generated schemas may change | state JSON is pinned by fixtures and user tooling | one superset JSON |
| 12 | `Workspace`/`Monitor` move by classifying each difference (cosmetic, same behaviour, real, missing), converging, then moving | a 25-member trait would hide real differences | per-platform copies |
| 13 | `Workspace<P>` hook signatures: fallible `begin_update`, `end_update` returns a pass, `place_window` returns a result; the Workspace move is atomic | review of the first design against KDE and Windows | finer hooks |
| 14 | Windows `komorebic visible-windows` lists unreadable windows with empty strings | a shared `visible_window_details` needs infallible details | restore the skip |
| 15 | `Layout::Custom` stays behind a Windows hook in the shared Workspace | unreachable on KDE; no KDE change | move the arms later |
| 16 | The KDE `vm-commands` handover failure is a test-precondition bug: fix the scenario, keep the check strict | an empty workspace cannot recalculate its layout; a check that cannot pass tests nothing | weaker check (rejected) |
| 17 | Freeze new behavioural stacks and stop the model move at the `WindowManager` boundary until gates catch up | shared text is 26-37%; gates were the critical path | resume sharing after gates |
| 18 | Revert the 1 s subscriber write timeout; fix the stale bar-running flag, the hwnd writer, dead-window bookkeeping, and add `komorebi-core` to default members | the timeout can truncate a notification and does not bound the stall | none (design needed: a bounded queue per subscriber) |
| 19 | Owner: KDE and macOS get the Windows pointer-picks-the-monitor behaviour for the workspace commands | consistency across platforms | per-platform preamble |
| 20 | Owner: explore deeper deduplication where it improves cross-platform testing | tests protect all three | stop at the boundary |
| 21 | Owner: software OpenGL fallback for the Windows bar (eframe `wgpu`, glow first, retry on failure) | the e2e guest has no OpenGL 2.0 | remove the feature |
| 22 | macOS keeps its own `Workspace::update` | adopting `update_shared` changes scrolling and cannot be verified without a Mac | adopt after the Mac pass |
| 23 | Formatting of real sources is applied last, with `tools/format-all` | formatting early conflicts with every open stack | none |
| 24 | The rule-list lock order is documented at the statics of each daemon (KDE, macOS, Windows) | two orders deadlocked on reload | none |
| 25 | Constant commit stamp (`nix-check`, `e2e`) in checks and e2e builds; only `packages.default` carries the real commit | a docs-only commit must be a cache hit | none |
| 26 | Gates are batched into candidates; a rebase invalidates a claim, so the gate is re-run at the tip | one revision compiled only because of a later fix | none |
+35
View File
@@ -1662,3 +1662,38 @@ settings), the lock, save and load commands, `Toggle*Override` and the work-area
`retile_all`, which has border calls on Windows), and the query commands (`State`, `GlobalState`,
`MonitorInformation`, schemas). These are the next clusters; `Promote`, `PromoteSwap` and `PromoteFocus`
are one-call arms with no logic to move. One-call arms were not counted as moved.
## 27. The macOS side of the shared router and `WindowManagerPlatform` (kfm, wip-u-mac-wm2)
Written while kfde's `gate_message` hook and `WindowManagerPlatform` trait (branch `wip-u-wm2`) did
not exist yet, so nothing here implements them; it records what macOS needs and what was done meanwhile.
**The gate (22.1).** macOS calls `handle_unmanaged_window_behaviour()` once, in `process_command`, after
`State::from` and before the `match`, for every message: the same call at the same place as KDE (KDE has
`is_layout_command` and maximized check before it, which macOS does not need, and macOS has a space-id
return before it, which KDE does not have). The body is the same text. So the default `gate_message`
(call it for every message) is what macOS does today, and macOS needs no override.
**Entry points as hooks** (the table of 22.2 for macOS; none takes the window manager lock from a main
queue closure, none dispatches to main itself; the ones that already block main under the lock keep the
hazard of `seam.md` 3.3 and do not add one):
| function | what it is on macOS | hook shape | seam note |
|---|---|---|---|
| `new(run_loop, incoming, custom_socket_path)` (50 lines) | takes the main run loop; builds monitors from nothing; a thin forward as `P::new(..)` needs the run loop as a platform argument | `fn new(&PlatformArgs) -> WindowManager<Self>` with the run loop in the platform's args | no lock |
| `init` (5 lines) | `MacosApi::load_monitor_information` then `load_workspace_information` (AX and CoreGraphics, on the calling thread) | `fn init(&mut WindowManager<Self>)` | runs before the daemon's threads start (main.rs), no lock contention |
| `stop(ignore_restore)` (26 lines) | restores windows, writes the state, closes subscriber sockets (takes `SUBSCRIPTION_SOCKETS`), exits | `fn stop(..)` | takes only the registry-like statics, not the WM lock again |
| `restore_all_windows(ignore_restore)` (17 lines) | AX restore per window | the shared part is the loop; the restore is `Container::restore` with the spot | AX under the WM lock, as before |
| `focus_workspace` (38) | calls `border_manager::hide_borders_on`, an `exec_sync` to main **under the WM lock** (the pre-existing hazard of 3.3) | hook `workspace_transition` | unchanged hazard; the hook must not make it worse (no second dispatch) |
| `resize_window` (240), `move_container_to_monitor` (130), `focus_floating_window_in_direction` (245), `enforce_workspace_rules` (202), `manage_focused_window` and `unmanage_focused_window` (19, 15) | the live-resize and AX identity code | stay macOS's; not hooks | |
`ReplaceConfiguration` is `replace_configuration`, taking the run loop from `self` (section 22 of this
document says it is a method since the deep dedup); the hook, if any, is `P::preload`.
**Done meanwhile.** `Minimize`, `Close` and `DebugWindow` are methods on both daemons (the arms are the same
text, the bodies the platform's); the ignore and manage rules use the shared `push_simple_rule`
(kind and id; macOS used to compare only the id, a small fix).
**`update` stays macOS's** (D-coord-15): section 22 gives the two blockers (the scrolling early return and
the width of the SkyLight batch), and the shared `WindowManager<P>` does not need `update`: it calls
`update_focused_workspace`, which is the daemon's.
+286
View File
@@ -0,0 +1,286 @@
# macOS hand-check plan: one runbook for the Mac pass
Status (wip-cand8, b6f4c2ae): OPEN. This is the ordered runbook that replaces reading
[macos-handcheck.md](macos-handcheck.md) top to bottom; that document stays as the source (rows A1-A..., B, C, D,
E, F, G, H and the review's H1-H12), and every item below says which row it came from. **Nothing here has been
run on a Mac as a daemon.** What did run, on a Mac Mini: `cargo build`, `clippy -D warnings`, `cargo test` (665
passed, 0 failed, 1 ignored at candidate 8) and the nix builds of `komorebi`, `komorebic`, `komorebi-bar` and the
darwin checks. No window has been tiled, hidden, focused or bordered by these builds.
How to read an item: **Steps**, **Expect**, **Stop / roll back**, **Introduced by** (jj bookmark or change id;
`jj log -r <id>` in the repository, commit ids move when a revision is rewritten). Items marked `[2 displays]`,
`[trackpad]`, `[physical]` need a second screen, a trackpad gesture, or someone to plug cables; `[2nd person]` is
useful where you cannot watch the screen and type at the same time. Block times are for a person who has the build
ready.
Order is by what could make the daemon unusable first. If a block fails, stop there, write down the block, item,
macOS version and the log lines, and do not continue to later blocks that depend on it (blocks 3 onwards assume
hiding and the event loop work).
## Do NOT run these on a Mac that has a live komorebi
The owner's Mac Mini runs their own komorebi. This runbook is for another Mac, or for a clean run on the Mini
after quitting the live daemon on purpose. Reasons are in the code: a second `komorebi` process exits with
"komorebi is already running" (it counts processes named `komorebi`), and on exit or Ctrl-C a daemon deletes
`$DATA_DIR/komorebi.sock`; all `komorebic` commands talk to the socket in the user's data directory, so they
reach whichever daemon owns it.
- Do not run `komorebic stop`, `komorebic stop --bar`, `komorebic start`, `komorebic quickstart`,
`komorebic enable-autostart` or `disable-autostart` (they run `launchctl load/unload`), `pkill`/`killall`
`komorebi` or `komorebi-bar` (`stop --bar` runs `pkill komorebi-bar`), or Ctrl-C the test daemon while the live
one shares the data directory.
- Do not run any `komorebic` command that changes state (`replace-configuration`,
`ignore-rule`, `session-float-rule`, `toggle-pause`, `focus-*`, `stack`, ...) unless you know which daemon it
reaches. `komorebic state` and `komorebic --help` are read-only.
- Do not `kill -STOP` or `kill -CONT` a pid you did not just start; items 8.2 and 8.3 are the only ones that use
signals and must use the pid of the test daemon or test bar, taken from `pgrep` right after you start them.
- Do not `cargo install`, `brew install/upgrade komorebi*` or overwrite the installed binaries; run from
`target/debug`.
- Do not use your real `~/.config/komorebi`: use the clean config in 0.2.
- Do not test on the live Mac's Accessibility grant by removing and re-adding it in System Settings; grant the
terminal that runs the test build.
A clean run on the Mini needs: quit the live daemon and bar in the way you normally do, confirm with
`pgrep -l komorebi` that nothing is left, run the runbook, then start your own again. `launchd` will restart an
auto-started daemon unless you disabled autostart yourself first.
## Block 0. Prerequisites and a build you can trust (about 25 min)
**0.1 Build and test.** From the repository root, with a `.git` checkout (or `COMMIT_HASH=dev`):
```sh
cargo build --locked -p komorebi -p komorebic -p komorebi-bar
cargo test --locked -p komorebi-macos -p komorebic -p komorebi-client -p komorebi-bar-core -p komorebi-bar -p komorebi-core -p komorebi-config -p komorebi-protocol
cargo clippy --locked -p komorebi -p komorebi-macos -p komorebic -p komorebi-client -p komorebi-bar -p komorebi-bar-core --all-targets -- -D warnings
```
Never name `-p komorebic-macos` together with `-p komorebic` (same binary name). Expect: 0 failures (the Mini
saw 665 passed, 0 failed, 1 ignored). Roll back: nothing to do; if a test fails, stop and report its name.
**0.2 A clean config and data directory.** Make an empty directory for the run, put a minimal
`komorebi.json` in it (copy `komorebi-for-mac/docs/komorebi.example.json`), and set `KOMOREBI_CONFIG_HOME` to it.
The data directory (socket, logs) is the user's `~/Library/Application Support/komorebi`, which this variable does
not change; use another Mac or a throwaway macOS user if you cannot guarantee the live daemon is not running.
Expect: `pgrep -l komorebi` prints nothing before you start.
**0.3 Permissions.** System Settings, Privacy and Security: grant Accessibility and Screen Recording to the
terminal you start the daemon from. Start the daemon in a visible terminal so you can Ctrl-C it:
`RUST_LOG=komorebi=debug target/debug/komorebi 2>&1 | tee run.log`.
**0.4 Baseline for comparison (optional).** Build the baseline ancestor `ff3711dc` of `wip-main` in another
checkout; a recording with `komorebi-recorder` on both builds makes before/after comparisons exact. The items
below say "as before" where this matters.
## Block 1. Startup, event loop and the command path (about 40 min)
The riskiest changes: the daemon now starts from a shared `daemon::run`, the command listener, pause filter,
subscriber push and event channel are the shared transport, and `SocketMessage` is the shared enum.
**1.1 Start and stop.** Steps: start the daemon (0.3); in another terminal `target/debug/komorebic state | head`,
`komorebic global-state | head`, `komorebic --version`, `target/debug/komorebi --version` (expect `komorebi 0.1.0`
with the macOS version crate). Then Ctrl-C the daemon. Expect: state is JSON; the daemon logs the restore of all
windows and exits (code 130), all windows are back where they were, `komorebi.sock` is gone. Stop: Ctrl-C; if the
daemon does not exit, `kill` the pid you started (not `pkill`). Introduced by: `wip-u-pkg2` (one `komorebi`
package, `1326f041`) and the shared transport revisions `nvwvptpv`, `ywwwwpwm`, `kzynysto`.
**1.2 Every command is answered.** Steps: run one command of each family: `focus left`, `move left`,
`resize-axis horizontal increase`, `stack`, `unstack`, `toggle-float`, `toggle-monocle`, `focus-workspace 1`,
`cycle-workspace next`, `toggle-pause` twice. Expect: each returns promptly; the log shows no
"could not acquire window manager lock". Introduced by: `lrqkuuzq`, `sowrttxs` (one `SocketMessage`), `nvwvptpv`.
Also `komorebic debug-window <id>` for a real window id from `state`, if your build lists it in `komorebic --help`.
**1.3 Pause filter.** `komorebic toggle-pause`; while paused only `toggle-pause`, `state`, `global-state`, `stop`
work, everything else is ignored; unpause and check that windows tile again. Introduced by: `ywwwwpwm`.
**1.4 Reload loop (the lock order).** Steps: in one terminal run `for i in $(seq 50); do komorebic
replace-configuration clean/komorebi.json; done` while you open
and close Finder windows and Terminal tabs. Expect: every call answered, no hang, new windows still tile; float,
ignore and manage rules from the config and from `komorebic session-float-rule`, `ignore-rule`, `manage-rule` still apply.
Stop: if the daemon stops answering, copy the log, `kill` the test daemon. Introduced by: `ummqkuvp` 01b9cbed
(one lock order; before it the order could deadlock) and `wip-u-rulematch` (the shared rule matcher: also try a
regex rule and a composite rule).
**1.5 Event channel under load.** Drag a window edge continuously (live resize), pan with the trackpad
`[trackpad]`, and switch workspaces with 10 or more windows. Expect: no stalls, no repeated "drop" warnings, the
layout follows. Introduced by: `ovsplvmn` (shared `EventChannel`).
**1.6 Subscribers.** `komorebic subscribe-socket mytest` in a terminal (and with options): events arrive for focus,
move, workspace change, monitor change, theme and config reload; kill the subscriber (Ctrl-C) and confirm the
daemon keeps answering. Introduced by: `kzynysto`.
Block done when: 1.1 to 1.6 hold. Do not go on if 1.1 or 1.4 fail.
## Block 2. Hiding and restoring windows (about 45 min; `[2 displays]` for 2.1)
The daemon's `Container`, `Workspace` and `Monitor` are now the shared `komorebi-core` types and hiding takes a
`HideSpot`. A bug here leaves windows stuck in a corner or lost.
**2.1 Hide spot on the right display (review H1) `[2 displays]`.** Steps: a window straddling the left edge of
display 2 (drag it half off). Switch workspace on display 2 and back. Repeat with `window_hiding_position:
"BottomRight"` in the monitor config (then `komorebic replace-configuration`). Stacks: `stack` three windows,
`cycle-stack`. Expect: the window is hidden in the `BottomLeft` corner of display 2 (not display 1, not left in
view) and restored to the same frame; only the front window of a stack is visible, the others sit in the corner.
Stop: Ctrl-C the test daemon (it restores every window on exit). Introduced by: `wip-u-kfm2` (Container, Workspace,
Monitor), the `HideSpot` revisions `ywowyyrz` and `losvwsls`, `wip-u-mac-deep` (`wlmxvuso`, `pulywuwk`, BEHAVIOUR:
the corner now comes from the workspace, not the monitor).
**2.2 Stacks, monocle and floating (H2 and the deep-dedup rows).** `toggle-float` a window, switch workspaces
twice: it hides and returns at its old frame. `toggle-monocle`, switch and back; with `window_hiding_position:
"BottomRight"` every other container parks in that corner while monocle is on; `cycle-focus` while monocle is on; `stack-all`;
change `window_hiding_position` in the config, reload and toggle monocle at once: the
corner must be the new one. Introduced by: `wip-u-mac-deep`.
**2.3 Workspaces.** `focus-workspace`, `send-to-workspace`, `move-to-workspace`, `cycle-move-to-workspace`,
`cycle-move-to-monitor` `[2 displays]`: windows of the workspace you left are hidden, those of the new one
restored where they were; focus-workspace by name too. Introduced by: `wip-u-kfm2`, `wip-u-cmd` (the moves are the
shared `komorebi-core::command` since candidate 7).
**2.4 Router arms moved to methods.** `toggle-workspace-layer` twice; `resize-axis horizontal|vertical
increase|decrease`; `session-float-rule` on a window; `ignore-rule exe <name>` and `title`/`class` (matching
windows leave the workspaces); `replace-configuration <komorebi.json>` (windows re-laid out under the new
configuration; with a broken file the daemon is left alone). Introduced by: `wip-u-mac-deep` (`tkpoootr`).
**2.5 Minimize, unminimize, close.** `minimize`, `close`, un-minimize from the Dock; closing removes the window
from its container. Introduced by: `Window` methods taking `&self` (`nrsnmwmo`).
Block done when: no window is ever left in a corner after unstack, quit or Ctrl-C, and `komorebic state` keys of a
container, workspace and monitor are unchanged (a container has `id`, `locked`, `windows.{elements,focused}`; a
monitor ends with `window_hiding_position`).
## Block 3. The window registry and leaks (about 40 min)
The daemon keeps a table from window id to Accessibility element (`ax_registry`) with retained references and
observers. Failures here show as memory growth or a hang, not as a wrong tile.
**3.1 Registry growth (H4).** Note `lsof -p $(pgrep -x komorebi) | wc -l` and `lsmp -p $(pgrep -x komorebi) |
tail -1` (Mach ports). In TextEdit open and close the Open and Save panels 200 times. Expect: no steady growth
(it also answers whether an `AXObserver` holds a port). Introduced by: `oywqqkuy`, `wip-u-kfm3`.
**3.2 Quit apps (H6).** `toggle-pause`, quit an app with managed windows, `toggle-pause`: its windows are gone from
`komorebic state`; with `RUST_LOG=debug` no new errors at quit; open and close 50 windows (Finder, Terminal,
Safari) and quit several apps: the daemon's memory in Activity Monitor does not climb. Introduced by: `wip-u-kfm3`
(`forget_pid`, forget on reap).
**3.3 Native tabs (H7).** Finder or Terminal with two native tabs: switch tab, close the first tab, open a new
tab, focus the window with `komorebic focus`, move and resize it. Expect: the window stays managed, focus works,
`komorebic state` shows one window id per container with no duplicates, no stuck border. Introduced by:
`oqnvyqvw` e0687167, `wip-u-kfm3`.
**3.4 A many-window app and a stopped one (H3).** Chrome with about 20 windows: restart the test daemon and note
the time to ready in the log against the baseline build. Then `kill -STOP <pid of one app with a managed window>`
and press `komorebic focus right` 5 times, then `kill -CONT <pid>`: commands are handled again within the AX
timeout after the CONT; a log line `invalidating application observer for process id` for a live app after the CONT
is the bug. Stop: always `kill -CONT` the app. Use the pid of a throwaway app (TextEdit), never of a system process.
## Block 4. Pointer picks the monitor (about 10 min, `[2 displays]`)
**4.1** An empty workspace on the second display with the pointer over it while the first display is focused:
`komorebic focus-workspace 1`, `focus-workspaces 1` and `focus-last-workspace` first focus the display under the
pointer, then switch its workspace (before, `focus-workspace` and `focus-workspaces` acted on the focused display).
With the pointer on the focused display nothing changes. Stop: move the pointer back and `focus-workspace` again.
Introduced by: `wip-u-ptr` (BEHAVIOUR, owner decision; shared `focus_workspace_number(s)`; macOS check H1 of
section H of the old list).
## Block 5. Settings and configuration reload (about 30 min)
Run settings are one snapshot (`komorebi-settings`) instead of statics. Test with `replace-configuration` or a
restart.
**5.1 Paddings, aspect ratio, layout defaults, display preferences (H9, G.1).** `default_workspace_padding` 20 and
`default_container_padding` 15: tiles 20 px from the work area and 15 apart on every workspace, not only the
focused. Drop the key and reload: padding stays; set 5: 5. `layout_defaults`: set, reload, workspaces use it; remove
and reload: reset. `floating_window_aspect_ratio`: `toggle-float` with centring uses it; remove and reload: 4:3.
`display_index_preference 0 <serial>`: monitor order follows it. Reload during a drag or workspace switch: no
one-frame flash of half-new padding. Introduced by: `wip-u-settings2`, `wip-u-settings3` (`qsxslsmy`).
**5.2 Animation (G.2, BEHAVIOUR).** `komorebic animation true`, switch workspace: a transition plays. During one,
`animation-duration 1000`, `animation-style`, `animation false`: the running transition is not torn, the next one
follows the new values. `animation true --movement` then `animation false`: movement is off again. Reload a file
with `"animation": {"enabled": {"movement": true}}`: only movement animates; with `"enabled": true` and no fps: fps
60; with no animation block: values keep. `animation-fps 30`. `stack` a window: no animation during the stack, back
after it. Introduced by: `mquxryqt` (settings S5).
**5.3 Schema and config loading (H-rows).** A real `komorebi.json` of yours loads with no new warning and every key
works (borders, padding, animations, scrolling, rules, workspaces); `komorebic static-config-schema` equals
`komorebi-for-mac/schema.json`. Introduced by: `kvtvnouo`, `stxmqnop` (StaticConfig from `komorebi-config`).
## Block 6. The rest of the daemon walk-through (about 60 min)
Compare with the baseline build where you can. Source: section C of the old list, with the Introduced-by rows A
and B for bisecting a regression (the B rows only rename and route: a failure there means a call went to the wrong
receiver).
6.1 Focus: `focus left|right|up|down`, `cycle-focus`, `focus-stack-window <n>`, mouse-follows-focus on and off, a tabbed
app (right tab focused). 6.2 Move and resize: `move`, `resize-axis`, `resize-edge`, a manual drag (the layout
puts the window back), live resize of one edge moves the neighbour, a fixed-size app. 6.3 Scrolling workspace (H8)
`[trackpad]`: `change-layout scrolling`, 5 windows, pan with the gesture and with `focus left/right`; scrolled-out
windows park at the screen edge (not the corner) and return on focus; switch workspace and back; consume, expel,
resize a column. 6.4 Borders: colours follow focus and animated windows; vanish and return on workspace switch;
none left behind after closing. 6.5 Animations on and off, ghost images, cancel by a new command mid-way. 6.6 Display
change `[physical]`: plug or unplug a monitor or change the resolution: work areas update, workspaces go to the
right monitors, rules re-apply (this is the thread that may deadlock, see 8.4). 6.7 Sleep and wake `[physical]`:
windows where they were, daemon answers, bar returns. 6.8 Start and stop: `komorebic start --bar`, `start
--await-configuration`, `stop`, `stop --bar` **only on a Mac with no live komorebi**, and `komorebic --help` plus a
few `<command> --help` texts (about 15 help texts now use the Windows wording). Introduced by: rows B and the
`komorebic` revisions `qukywpss`, `zwkwptox`, `sxptsttt` (shared launcher and pan).
## Block 7. The bar (about 25 min)
The bar is now the `komorebi-bar` package (module `macos`) over `komorebi-bar-core`, with `sysinfo` 0.39 and
`starship-battery` 0.11.
**7.1 Renders.** `target/debug/komorebi-bar` against the running test daemon: workspaces, layout, CPU %, memory,
battery % and charging, date and the calendar icon, all sane. `komorebi-bar --schema | cmp - komorebi-for-mac/schema.bar.json`
is silent. Introduced by: `wip-u-pkg-mig` bar revisions (`7d4ea893`, `bdd811f2`), `nottqpms` and the bar-core hooks.
**7.2 Old state and the bar (H10).** `komorebic state > old.json` on the ORIGINAL build; start the new bar against
the new daemon and confirm it renders; the new daemon's `state` parses in the bar.
**7.3 Bar config (H11).** A Keyboard, Media and Systray widget and a `mouse` block in `komorebi.bar.json`: the bar
starts, logs "the Keyboard widget is not supported on this platform and is skipped" (three times) and the `mouse`
warning, and renders the other widgets. Break the file (`"mouse": {"on_scroll_up": 5}` or an unknown widget): the bar
refuses to load it with an error. Introduced by: bar decision (macOS accepts and skips Windows-only keys).
**7.4 Clicks (old M1-M3).** Battery click opens System Settings on the Battery pane (macOS 13 or later; write down
the macOS version and what opened if wrong); CPU and memory click opens Activity Monitor; network opens the
Network pane; storage opens the folder in Finder; update widget (installed version older than the latest release)
shows the new version and the click opens `https://github.com/LGUG2Z/komorebi-for-mac/releases/tag/v<version>`;
after 12 hours (or a small `data_refresh_interval`) it still compares against komorebi-for-mac releases.
Introduced by: `tpwlsxpm`, `tsxllpxz`.
## Block 8. Known issues to confirm (about 20 min; these are expected to misbehave)
**8.1 Unsupported commands (H12).** `echo '"ToggleMaximize"' | nc -U "$HOME/Library/Application Support/komorebi/komorebi.sock"`:
a not-supported reply, no state change, the daemon keeps running.
**8.2 Hung subscriber (H5, known, not fixed).** `kill -STOP $(pgrep komorebi-bar)` (the bar you started in 7),
then `komorebic focus left` 10 times and watch the log for "could not acquire window manager lock": the daemon is
expected to stop reacting once the socket buffer fills. Roll back: `kill -CONT` that bar pid. See
[known-issues.md](known-issues.md) item 4.
**8.3 Deadlock window (old bug A, by reading only).** Spam `komorebic retile` and workspace switches (with
animations) while plugging and unplugging a monitor `[physical]`; the symptom is a daemon that answers no command
(`komorebic state` hangs). Stop: `kill` the test daemon; windows may stay hidden, so quit it with Ctrl-C if it still responds (the daemon
restores windows on exit), otherwise `kill` it and move the hidden windows back by hand.
**8.4 Other bugs on the old list (D, B, C)** that remain by design: raw Accessibility calls outside `Window`, the
update widget second URL (now fixed by `tsxllpxz`), the `cmd.exe`/`explorer.exe` clicks (fixed by `tpwlsxpm`).
## Time and what to report
| Block | Needs | Time |
|---|---|---|
| 0 prerequisites | build, a spare Mac | 25 min |
| 1 startup and command path | 1 display | 40 min |
| 2 hiding and restoring | 2 displays for 2.1, 2.3 (monitor move) | 45 min |
| 3 registry and leaks | Activity Monitor, `lsof`, `lsmp` | 40 min |
| 4 pointer picks the monitor | 2 displays | 10 min |
| 5 settings and reload | none | 30 min |
| 6 walk-through | trackpad, display cables, lid | 60 min |
| 7 bar | none | 25 min |
| 8 known issues | cables | 20 min |
| total | | about 5 hours |
Report per item: block and item number, macOS version, pass or fail, and for a failure the `run.log` lines and
`komorebic state`. A failure in Block 1 or 2 blocks landing any further macOS change; failures in later blocks are
bugs to fix in the revision named under Introduced by.
+2
View File
@@ -99,6 +99,8 @@ timeout. Until then H5 documents the hang.
| `wip-u-kfm3` registry fixes (see `jj log -r wip-u-kfm3`) | The registry keeps inert application copies (no blocking Accessibility call when an entry is dropped), a window is registered when its observer is attached, a clone being dropped no longer deregisters its window, `forget_pid` runs ahead of the pause and other-space returns, and the application reaper forgets what it reaps. Nothing reads the registry except the unused `MacosBackend`. | H3, H4, H6, H7 above, and the usual walk-through: no change in what the daemon does is expected. |
| deep dedup 1: `refactor(mac): the daemon uses the shared Container API with the hide spot` (see `jj log -r wip-u-mac-deep`) | `ContainerExt` (`add_window_at`, `load_focused_window_at`, `hide_on`, `restore_focused_window`) is gone: every call is the shared `Container::{add_window, load_focused_window, hide, restore}` with `workspace.hide_spot()`. `monocle_on` and `cycle_monocle` took the corner from the monitor (`monitor.extra`) and now take it from the workspace (`workspace.state`), which the monitor writes with the globals; `restore()` now skips the Accessibility call under `cfg!(test)`. | `cargo test`; then H1 (hide spot) and: toggle monocle on a workspace with two containers on a monitor with `window_hiding_position: BottomRight` (every other container parks in that corner), cycle the monocle container, stack with `komorebic stack`/`stack-all`, `cycle-stack`, `add-window-to-container`, switch workspaces. Change the monitor's `window_hiding_position` in the config, reload, and toggle monocle at once: the corner must be the new one. |
| deep dedup 2: `refactor(mac): five router arms are methods with the KDE names` | `ToggleWorkspaceLayer`, `ResizeWindowAxis`, `SessionFloatRule`, `IgnoreRule` and `ReplaceConfiguration` call `toggle_workspace_layer`, `resize_window_axis`, `add_session_float_rule`, `add_ignore_rule(identifier, id: &str)` and `replace_configuration(&PathBuf)`, with the bodies the arms had (a pure move; the router arms are now the KDE text). `id` of the ignore rule is a `&str`, compared with `==`. | `cargo test`; by hand: `komorebic toggle-workspace-layer` twice (tiling to floating and back: a window of the layer is focused, the others hide at the corner and come back), `resize-axis horizontal|vertical increase|decrease`, `komorebic session-float-rule` on a window, `komorebic ignore-rule exe <name>` and `ignore-rule title/class` (the matching windows leave the workspaces), `komorebic replace-configuration <komorebi.json>` (the daemon restarts its windows under the new config; with a broken file it is left alone). |
| wm2 1: `refactor(mac): ignore and manage rules go through the shared push_simple_rule` | `ignore-rule` and `manage-rule` add a rule unless a simple rule of the same kind and id exists. The macOS code checked only the id, so `ignore-rule class foo` after `ignore-rule exe foo` was silently dropped; it is added now (this is the KDE behaviour, which a KDE test pins). | `komorebic ignore-rule exe Notes`, then `ignore-rule title Notes`: both rules are in `komorebic state` ... `ignore_identifiers` (before, the second was not). Running the same command twice adds one rule. `manage-rule` the same. |
| wm2 2: `refactor(mac): Minimize, Close and DebugWindow are methods` | The arms call `minimize_foreground_window`, `close_foreground_window` and `debug_window(window_id, reply)` with the bodies they had. | `komorebic minimize` and `komorebic close` on the focused window of another app (the window minimizes / closes; with no foreground window an error is logged), `komorebic debug-window <id>` for a real window id (the rule debug JSON is printed) and for an id that does not exist (nothing printed, no error). |
Revisions in section B change no behaviour on purpose (rename, move, route); they still need the sections C walk-through, because a mechanical mistake would show there.
@@ -268,6 +268,7 @@ use crate::workspace::WorkspaceWindowLocation;
use color_eyre::eyre;
use color_eyre::eyre::Context;
use color_eyre::eyre::OptionExt;
use komorebi_config::matching::push_simple_rule;
use komorebi_themes::colour::Rgb;
use komorebi_transport::CommandTarget;
use komorebi_transport::NoPolicy;
@@ -1247,18 +1248,8 @@ impl WindowManager {
SocketMessage::ResizeWindowAxis(axis, sizing) => {
self.resize_window_axis(axis, sizing)?
}
SocketMessage::Minimize => {
let foreground_window = backend()
.foreground_window()
.ok_or_eyre("there is no foreground window")?;
Window::from(foreground_window).minimize()?;
}
SocketMessage::Close => {
let foreground_window = backend()
.foreground_window()
.ok_or_eyre("there is no foreground window")?;
Window::from(foreground_window).close()?;
}
SocketMessage::Minimize => self.minimize_foreground_window()?,
SocketMessage::Close => self.close_foreground_window()?,
SocketMessage::ManageFocusedWindow => {
self.manage_focused_window()?;
}
@@ -1724,19 +1715,7 @@ impl WindowManager {
workspace.resize_dimensions = resize;
self.update_focused_workspace(false, false)?;
}
SocketMessage::DebugWindow(window_id) => {
// an id that is not a u32 is not a window
let window = u32::try_from(window_id).map(Window::from);
if let Ok(window) = window
&& window.is_valid()
{
let mut rule_debug = RuleDebug::default();
let _ = window.should_manage(None, &mut rule_debug);
let schema = serde_json::to_string_pretty(&rule_debug)?;
reply.write_all(schema.as_bytes())?;
}
}
SocketMessage::DebugWindow(window_id) => self.debug_window(window_id, &mut reply)?,
SocketMessage::Border(enable) => {
border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
if !enable {
@@ -1899,19 +1878,43 @@ pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) ->
komorebi_transport::read_commands::<WindowManager, _>(wm, stream, &NoPolicy)
}
/// Add a simple socket-created rule unless one with the same kind and id is already present;
/// a rule of another kind with the same id is a different rule
fn push_simple_rule(rules: &mut Vec<MatchingRule>, kind: ApplicationIdentifier, id: &str) {
let exists = rules
.iter()
.any(|r| matches!(r, MatchingRule::Simple(r) if r.kind == kind && r.id.eq(id)));
impl WindowManager {
/// Minimizes the window that has the focus
pub fn minimize_foreground_window(&mut self) -> eyre::Result<()> {
let foreground_window = backend()
.foreground_window()
.ok_or_eyre("there is no foreground window")?;
Window::from(foreground_window).minimize()?;
Ok(())
}
if !exists {
rules.push(MatchingRule::Simple(IdWithIdentifier {
kind,
id: id.to_string(),
matching_strategy: Option::from(MatchingStrategy::Legacy),
}));
/// Closes the window that has the focus
pub fn close_foreground_window(&mut self) -> eyre::Result<()> {
let foreground_window = backend()
.foreground_window()
.ok_or_eyre("there is no foreground window")?;
Window::from(foreground_window).close()?;
Ok(())
}
/// Answers with why the window of this id is, or is not, managed
pub fn debug_window(
&self,
window_id: i64,
reply: &mut impl std::io::Write,
) -> eyre::Result<()> {
// an id that is not a u32 is not a window
let window = u32::try_from(window_id).map(Window::from);
if let Ok(window) = window
&& window.is_valid()
{
let mut rule_debug = RuleDebug::default();
let _ = window.should_manage(None, &mut rule_debug);
let schema = serde_json::to_string_pretty(&rule_debug)?;
reply.write_all(schema.as_bytes())?;
}
Ok(())
}
}
@@ -2397,26 +2400,4 @@ mod tests {
std::fs::remove_file(socket_path).unwrap();
}
#[test]
fn push_simple_rule_keeps_rules_of_another_kind_with_the_same_id() {
let mut rules = vec![];
push_simple_rule(&mut rules, ApplicationIdentifier::Class, "foo");
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
assert_eq!(rules.len(), 2);
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
push_simple_rule(&mut rules, ApplicationIdentifier::Class, "foo");
assert_eq!(rules.len(), 2);
rules.clear();
rules.push(MatchingRule::Composite(vec![IdWithIdentifier {
kind: ApplicationIdentifier::Exe,
id: "foo".to_string(),
matching_strategy: None,
}]));
push_simple_rule(&mut rules, ApplicationIdentifier::Exe, "foo");
assert_eq!(rules.len(), 2);
}
}
@@ -31,6 +31,7 @@ use crate::core::config_generation::WorkspaceMatchingRule;
use crate::monitor::MonitorExt;
use crate::scrolling::WorkspaceScrolling;
use crate::workspace::WorkspaceExt;
use komorebi_config::matching::push_simple_rule;
use crate::core_graphics::CoreGraphicsApi;
use crate::current_space_id;
@@ -474,16 +475,8 @@ impl WindowManager {
let _suspended_animations = animation::suspend();
self.focus_container_window(idx)?;
}
SocketMessage::Minimize => {
let foreground_window =
MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?;
AdhocWindow::minimize(&foreground_window)?;
}
SocketMessage::Close => {
let foreground_window =
MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?;
AdhocWindow::close(&foreground_window)?;
}
SocketMessage::Minimize => self.minimize_foreground_window()?,
SocketMessage::Close => self.close_foreground_window()?,
SocketMessage::ManageFocusedWindow => {
self.manage_focused_window()?;
}
@@ -815,22 +808,7 @@ impl WindowManager {
SocketMessage::ManageRule(identifier, ref id) => {
let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
let mut should_push = true;
for m in &*manage_identifiers {
if let MatchingRule::Simple(m) = m
&& m.id.eq(id)
{
should_push = false;
}
}
if should_push {
manage_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
kind: identifier,
id: id.clone(),
matching_strategy: Option::from(MatchingStrategy::Legacy),
}));
}
push_simple_rule(&mut manage_identifiers, identifier, id);
}
SocketMessage::NewWorkspace => {
self.new_workspace()?;
@@ -1137,28 +1115,7 @@ impl WindowManager {
workspace.resize_dimensions = resize;
self.update_focused_workspace(false, false)?;
}
SocketMessage::DebugWindow(window_id) => {
if let Some(window_list_info) = CoreGraphicsApi::window_list_info() {
for raw_window_info in cf_array_as::<CFDictionary>(&window_list_info) {
let raw_info = WindowInfo::new(raw_window_info);
let application = Application::new(raw_info.owner_pid)?;
if let Some(elements) = application.window_elements() {
for element in elements {
if let Ok(wid) = crate::ax_registry::identify(&element)
&& i64::from(wid) == window_id
&& let Ok(window) = Window::new(element, application.clone())
{
let mut rule_debug = RuleDebug::default();
let _ = window.should_manage(None, &mut rule_debug);
let schema = serde_json::to_string_pretty(&rule_debug)?;
reply.write_all(schema.as_bytes())?;
}
}
}
}
}
}
SocketMessage::DebugWindow(window_id) => self.debug_window(window_id, &mut reply)?,
SocketMessage::DisplayIndexPreference(index_preference, ref display) => {
crate::settings::settings().update(|settings| {
settings
@@ -1491,22 +1448,7 @@ impl WindowManager {
) -> eyre::Result<()> {
let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock();
let mut should_push = true;
for i in &*ignore_identifiers {
if let MatchingRule::Simple(i) = i
&& i.id == id
{
should_push = false;
}
}
if should_push {
ignore_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
kind: identifier,
id: id.to_string(),
matching_strategy: Option::from(MatchingStrategy::Legacy),
}));
}
push_simple_rule(&mut ignore_identifiers, identifier, id);
let offset = self.work_area_offset;
@@ -1598,6 +1540,53 @@ impl WindowManager {
}
}
impl WindowManager {
/// Minimizes the window that has the focus
pub fn minimize_foreground_window(&mut self) -> eyre::Result<()> {
let foreground_window =
MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?;
AdhocWindow::minimize(&foreground_window)?;
Ok(())
}
/// Closes the window that has the focus
pub fn close_foreground_window(&mut self) -> eyre::Result<()> {
let foreground_window =
MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?;
AdhocWindow::close(&foreground_window)?;
Ok(())
}
/// Answers with why the window of this id is, or is not, managed
pub fn debug_window(
&self,
window_id: i64,
reply: &mut impl std::io::Write,
) -> eyre::Result<()> {
if let Some(window_list_info) = CoreGraphicsApi::window_list_info() {
for raw_window_info in cf_array_as::<CFDictionary>(&window_list_info) {
let raw_info = WindowInfo::new(raw_window_info);
let application = Application::new(raw_info.owner_pid)?;
if let Some(elements) = application.window_elements() {
for element in elements {
if let Ok(wid) = crate::ax_registry::identify(&element)
&& i64::from(wid) == window_id
&& let Ok(window) = Window::new(element, application.clone())
{
let mut rule_debug = RuleDebug::default();
let _ = window.should_manage(None, &mut rule_debug);
let schema = serde_json::to_string_pretty(&rule_debug)?;
reply.write_all(schema.as_bytes())?;
}
}
}
}
}
Ok(())
}
}
/// The window manager as the shared commands of `komorebi_core::command` see it
impl komorebi_core::CommandHost for WindowManager {
type P = crate::workspace::MacosPlatform;