summon-switcher 0.1.0

A tiny macOS command-line tool for opening, focusing, and cycling applications from declarative keybindings.
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
131
132
133
134
135
136
137
138
139

//! Daemon client for socket-based summon requests.

use std::io::{Read, Write};
use std::net::Shutdown;
use std::os::unix::net::UnixStream;
use std::path::Path;
use std::time::Duration;

use serde::de::DeserializeOwned;
use thiserror::Error;

use crate::daemon::protocol::{
    PROTOCOL_VERSION, RequestEnvelope, Response, ResponseEnvelope, Status,
};
use crate::runner::RunOutput;

/// Errors from daemon client operations.
#[derive(Debug, Error)]
pub enum ClientError {
    /// The daemon socket could not be reached.
    #[error("Summon daemon is unavailable at {socket}: {reason}")]
    Unavailable {
        /// Socket path that failed.
        socket: String,
        /// Connection failure.
        reason: String,
    },

    /// The daemon returned an unexpected protocol version.
    #[error("Summon daemon protocol mismatch at {socket}: expected v{expected}, got v{actual}")]
    ProtocolMismatch {
        /// Socket path that replied.
        socket: String,
        /// Expected version.
        expected: u32,
        /// Actual version.
        actual: u32,
    },

    /// The daemon response could not be parsed.
    #[error("Could not decode summon daemon response from {socket}: {reason}")]
    Decode {
        /// Socket path that replied.
        socket: String,
        /// Decode error.
        reason: String,
    },

    /// The daemon returned an unexpected response type.
    #[error("Unexpected summon daemon response from {socket}")]
    UnexpectedResponse {
        /// Socket path that replied.
        socket: String,
    },
}

/// Sends a daemon request and returns the raw response.
pub fn send(socket_path: &Path, request: RequestEnvelope) -> Result<ResponseEnvelope, ClientError> {
    let socket_label = socket_path.display().to_string();
    let mut stream = UnixStream::connect(socket_path).map_err(|err| ClientError::Unavailable {
        socket: socket_label.clone(),
        reason: err.to_string(),
    })?;
    let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
    let _ = stream.set_write_timeout(Some(Duration::from_millis(500)));

    write_json(&mut stream, &request).map_err(|err| ClientError::Unavailable {
        socket: socket_label.clone(),
        reason: err.to_string(),
    })?;
    let _ = stream.shutdown(Shutdown::Write);

    let response: ResponseEnvelope = read_json(&mut stream).map_err(|err| ClientError::Decode {
        socket: socket_label.clone(),
        reason: err,
    })?;

    if response.version != PROTOCOL_VERSION {
        return Err(ClientError::ProtocolMismatch {
            socket: socket_label,
            expected: PROTOCOL_VERSION,
            actual: response.version,
        });
    }

    Ok(response)
}

/// Sends a daemon request that should return a run result.
pub fn run(socket_path: &Path, request: RequestEnvelope) -> Result<RunOutput, ClientError> {
    let response = send(socket_path, request)?;
    match response.response {
        Response::Run(output) => Ok(output),
        _ => Err(ClientError::UnexpectedResponse {
            socket: socket_path.display().to_string(),
        }),
    }
}

/// Pings the daemon and returns its status.
pub fn ping(socket_path: &Path) -> Result<Status, ClientError> {
    let response = send(
        socket_path,
        RequestEnvelope::new(crate::daemon::protocol::Request::Ping),
    )?;
    match response.response {
        Response::Pong(status) => Ok(status),
        _ => Err(ClientError::UnexpectedResponse {
            socket: socket_path.display().to_string(),
        }),
    }
}

/// Requests a graceful daemon shutdown.
pub fn stop(socket_path: &Path) -> Result<(), ClientError> {
    let response = send(
        socket_path,
        RequestEnvelope::new(crate::daemon::protocol::Request::Stop),
    )?;
    match response.response {
        Response::Stopped => Ok(()),
        _ => Err(ClientError::UnexpectedResponse {
            socket: socket_path.display().to_string(),
        }),
    }
}

fn write_json<T: serde::Serialize>(stream: &mut UnixStream, value: &T) -> std::io::Result<()> {
    serde_json::to_writer(&mut *stream, value)?;
    stream.write_all(b"\n")
}

fn read_json<T: DeserializeOwned>(stream: &mut UnixStream) -> Result<T, String> {
    let mut buffer = Vec::new();
    stream
        .read_to_end(&mut buffer)
        .map_err(|err| err.to_string())?;
    serde_json::from_slice(&buffer).map_err(|err| err.to_string())
}