kagikey 0.4.0

Cross-platform key mapper with first-class IME control
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Backend contract. Each platform owns capture, synthesis and IME control;
//! everything above this line is platform-neutral.

use crate::action::{Action, ImeState};
use crate::config::Config;
use crate::engine::Engine;
use crate::keys::Chord;
use anyhow::{Context, Result};
use std::process::{Command, Stdio};

/// Synthesis side of a backend: what a matched rule can drive.
pub trait Emitter {
    /// Press and release `chord`, with only `chord.mods` applied — the
    /// physically held modifiers must not leak into the synthetic event.
    fn tap(&mut self, chord: Chord) -> Result<()>;
    /// Open/close/toggle the IME of the focused window.
    fn ime(&mut self, state: ImeState) -> Result<()>;
    /// Select an input source by platform-native id.
    fn input_source(&mut self, id: &str) -> Result<()>;
}

/// Run a matched rule's actions in order.
pub fn dispatch(emitter: &mut dyn Emitter, actions: &[Action]) -> Result<()> {
    for action in actions {
        match action {
            Action::Tap(chord) => emitter.tap(*chord)?,
            Action::Ime(state) => emitter.ime(*state)?,
            Action::InputSource(id) => emitter.input_source(id)?,
            Action::Cmd(cmd) => spawn_detached(cmd)?,
        }
    }
    Ok(())
}

/// Fire-and-forget shell command. Reaped on a helper thread so a long-lived
/// daemon does not accumulate zombies.
pub fn spawn_detached(cmd: &str) -> Result<()> {
    let mut command = if cfg!(target_os = "windows") {
        let mut c = Command::new("cmd");
        c.args(["/C", cmd]);
        c
    } else {
        let mut c = Command::new("sh");
        c.args(["-c", cmd]);
        c
    };
    let child = command
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .with_context(|| format!("spawning `{cmd}`"))?;
    std::thread::spawn(move || {
        let mut child = child;
        let _ = child.wait();
    });
    Ok(())
}

/// Run `cmd` and report whether it exited successfully. Used by the Linux
/// backend to probe IME helpers (fcitx5, ibus) in order.
#[allow(dead_code)]
pub fn run_blocking(cmd: &str) -> bool {
    let mut command = if cfg!(target_os = "windows") {
        let mut c = Command::new("cmd");
        c.args(["/C", cmd]);
        c
    } else {
        let mut c = Command::new("sh");
        c.args(["-c", cmd]);
        c
    };
    command
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status()
        .map(|s| s.success())
        .unwrap_or(false)
}

#[cfg(target_os = "macos")]
mod macos;
#[cfg(target_os = "macos")]
use macos as imp;

#[cfg(target_os = "windows")]
mod windows;
#[cfg(target_os = "windows")]
use windows as imp;

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
use linux as imp;

#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
compile_error!("kagi supports macOS, Windows and Linux only");

/// Capture keys and apply `engine` until interrupted.
pub fn run(engine: Engine, config: &Config) -> Result<()> {
    imp::run(engine, config)
}

/// Print key events as they arrive, without remapping. Used to discover the
/// names to put in a config.
pub fn watch(config: &Config) -> Result<()> {
    imp::watch(config)
}

/// Ask the OS for whatever kagi needs to capture keys, and report whether it
/// has it. Safe to call repeatedly.
#[cfg(target_os = "macos")]
pub fn request_permissions() -> Result<bool> {
    imp::request_permissions(imp::Prompt::Always)
}

#[cfg(not(target_os = "macos"))]
pub fn request_permissions() -> Result<bool> {
    // Only macOS gates capture behind a per-binary grant that has to be
    // requested before the binary even appears in the settings list. Linux
    // needs device permissions, which `kagi run` already reports with the
    // exact remedy, and a Windows hook needs nothing below its own integrity
    // level.
    println!(
        "no per-binary permission grant is required on {}",
        std::env::consts::OS
    );
    Ok(true)
}