cueward-adapter-macos 0.5.0

macOS adapter for Cueward with Safari, Notes, Messages, Reminders, Calendar, Screenshot, Clipboard, and OCR integrations.
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

use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use serde::{Deserialize, Serialize};

use super::super::input_target::InputTarget;
use super::super::target::WindowIdentity;
use crate::MacosError;

#[derive(Debug, Serialize, Deserialize)]
struct SpaceTarget {
    kind: String,
    version: u8,
    issued_at: u64,
    window: WindowIdentity,
    space_ids: Vec<u64>,
}

pub(super) struct MoveTarget {
    pub issued_at: u64,
    pub window: WindowIdentity,
    pub expected_spaces: Option<Vec<u64>>,
}

fn invalid() -> MacosError {
    MacosError::Other(
        "invalid or expired Space move target; observe with space window again".into(),
    )
}

fn valid_spaces(ids: &[u64]) -> bool {
    !ids.is_empty() && ids.len() <= 64 && ids[0] > 0 && ids.windows(2).all(|pair| pair[0] < pair[1])
}

impl MoveTarget {
    /// Bind a Space-only target to the observed window and source membership.
    pub fn issue(
        window: WindowIdentity,
        mut space_ids: Vec<u64>,
        issued_at: u64,
    ) -> Result<String, MacosError> {
        space_ids.sort_unstable();
        if !valid_spaces(&space_ids) || !valid_window(&window) {
            return Err(invalid());
        }
        let target = SpaceTarget {
            kind: "space_move".into(),
            version: 1,
            issued_at,
            window,
            space_ids,
        };
        serde_json::to_vec(&target)
            .map(|bytes| URL_SAFE_NO_PAD.encode(bytes))
            .map_err(|_| invalid())
    }

    /// Validate a membership target or a legacy snapshot target for movement.
    pub fn decode(token: &str, now: u64) -> Result<Self, MacosError> {
        if token.len() > 16_384 {
            return Err(invalid());
        }
        let bytes = URL_SAFE_NO_PAD.decode(token).map_err(|_| invalid())?;
        let value: serde_json::Value = serde_json::from_slice(&bytes).map_err(|_| invalid())?;
        if value["kind"] == "window_input" {
            let target = InputTarget::decode(token, now)?;
            return Ok(Self {
                issued_at: target.issued_at,
                window: target.window,
                expected_spaces: None,
            });
        }
        let target: SpaceTarget = serde_json::from_value(value).map_err(|_| invalid())?;
        if target.kind != "space_move"
            || target.version != 1
            || now
                .checked_sub(target.issued_at)
                .is_none_or(|age| age > 300)
            || !valid_window(&target.window)
            || !valid_spaces(&target.space_ids)
        {
            return Err(invalid());
        }
        Ok(Self {
            issued_at: target.issued_at,
            window: target.window,
            expected_spaces: Some(target.space_ids),
        })
    }
}

fn valid_window(window: &WindowIdentity) -> bool {
    window.window_id > 0
        && window.owner_pid > 0
        && window.bounds.width > 0
        && window.bounds.height > 0
}

#[cfg(test)]
#[path = "space_target_tests.rs"]
mod tests;