workmux 0.1.174

An opinionated workflow tool that orchestrates git worktrees and tmux
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
140
141
142
143
144

//! Unified handle for multiplexer targets (windows or sessions).
//!
//! Centralizes all mode-dependent dispatch so callers don't need
//! `if mode == Session { ... } else { ... }` branches.

use anyhow::Result;
use std::time::Duration;

use crate::config::MuxMode;

use super::Multiplexer;
use super::util;

/// Returns "window" or "session" for a given mode.
pub fn mode_label(mode: MuxMode) -> &'static str {
    match mode {
        MuxMode::Window => "window",
        MuxMode::Session => "session",
    }
}

/// A unified handle for a multiplexer target (window or session).
///
/// Wraps a reference to the backend, the mode, prefix, and handle name,
/// then dispatches to the correct window or session methods.
pub struct MuxHandle<'a> {
    mux: &'a dyn Multiplexer,
    mode: MuxMode,
    prefix: &'a str,
    name: &'a str,
}

impl<'a> MuxHandle<'a> {
    pub fn new(mux: &'a dyn Multiplexer, mode: MuxMode, prefix: &'a str, name: &'a str) -> Self {
        Self {
            mux,
            mode,
            prefix,
            name,
        }
    }

    /// Returns "window" or "session".
    pub fn kind(&self) -> &'static str {
        mode_label(self.mode)
    }

    pub fn is_session(&self) -> bool {
        self.mode == MuxMode::Session
    }

    /// The prefixed name (e.g., "wm-feature-auth").
    pub fn full_name(&self) -> String {
        util::prefixed(self.prefix, self.name)
    }

    /// Check if the target exists.
    pub fn exists(&self) -> Result<bool> {
        let full = self.full_name();
        match self.mode {
            MuxMode::Session => self.mux.session_exists(&full),
            MuxMode::Window => self.mux.window_exists(self.prefix, self.name),
        }
    }

    /// Check if a target exists by its full name (including prefix).
    /// Useful when the full name was obtained from current_name() or similar.
    pub fn exists_full(mux: &dyn Multiplexer, mode: MuxMode, full_name: &str) -> Result<bool> {
        match mode {
            MuxMode::Session => mux.session_exists(full_name),
            MuxMode::Window => mux.window_exists_by_full_name(full_name),
        }
    }

    /// Activate (focus/switch to) the target.
    pub fn select(&self) -> Result<()> {
        match self.mode {
            MuxMode::Session => self.mux.switch_to_session(self.prefix, self.name),
            MuxMode::Window => self.mux.select_window(self.prefix, self.name),
        }
    }

    /// Kill a target by its full name.
    pub fn kill_full(mux: &dyn Multiplexer, mode: MuxMode, full_name: &str) -> Result<()> {
        match mode {
            MuxMode::Session => mux.kill_session(full_name),
            MuxMode::Window => mux.kill_window(full_name),
        }
    }

    /// Schedule a target to close after a delay, by full name.
    pub fn schedule_close_full(
        mux: &dyn Multiplexer,
        mode: MuxMode,
        full_name: &str,
        delay: Duration,
    ) -> Result<()> {
        match mode {
            MuxMode::Session => mux.schedule_session_close(full_name, delay),
            MuxMode::Window => mux.schedule_window_close(full_name, delay),
        }
    }

    /// Get the current target name (session name or window name).
    pub fn current_name(&self) -> Result<Option<String>> {
        match self.mode {
            MuxMode::Session => Ok(self.mux.current_session()),
            MuxMode::Window => self.mux.current_window_name(),
        }
    }

    /// Wait until the target is closed.
    pub fn wait_until_closed(&self) -> Result<()> {
        let full = self.full_name();
        match self.mode {
            MuxMode::Session => self.mux.wait_until_session_closed(&full),
            MuxMode::Window => self.mux.wait_until_windows_closed(&[full]),
        }
    }

    /// Generate a shell command to kill a target by full name (for deferred scripts).
    pub fn shell_kill_cmd_full(
        mux: &dyn Multiplexer,
        mode: MuxMode,
        full_name: &str,
    ) -> Result<String> {
        match mode {
            MuxMode::Session => mux.shell_kill_session_cmd(full_name),
            MuxMode::Window => mux.shell_kill_window_cmd(full_name),
        }
    }

    /// Generate a shell command to select a target by full name (for deferred scripts).
    pub fn shell_select_cmd_full(
        mux: &dyn Multiplexer,
        mode: MuxMode,
        full_name: &str,
    ) -> Result<String> {
        match mode {
            MuxMode::Session => mux.shell_switch_session_cmd(full_name),
            MuxMode::Window => mux.shell_select_window_cmd(full_name),
        }
    }
}