proc_cli/commands/
stop.rs

1//! Stop command - Graceful process termination (SIGTERM)
2//!
3//! Usage:
4//!   proc stop 1234              # Stop PID 1234
5//!   proc stop :3000             # Stop process on port 3000
6//!   proc stop node              # Stop all node processes
7//!   proc stop :3000,:8080       # Stop multiple targets
8//!   proc stop :3000,1234,node   # Mixed targets (port + PID + name)
9
10#[cfg(unix)]
11use crate::core::parse_signal_name;
12use crate::core::{apply_filters, parse_targets, resolve_targets_excluding_self, Process};
13use crate::error::{ProcError, Result};
14use crate::ui::Printer;
15use clap::Args;
16
17/// Stop process(es) gracefully with SIGTERM
18#[derive(Args, Debug)]
19pub struct StopCommand {
20    /// Target(s): process name, PID, or :port (comma-separated for multiple)
21    #[arg(required = true)]
22    target: String,
23
24    /// Skip confirmation prompt
25    #[arg(long, short = 'y')]
26    yes: bool,
27
28    /// Show what would be stopped without actually stopping
29    #[arg(long)]
30    dry_run: bool,
31
32    /// Output as JSON
33    #[arg(long, short = 'j')]
34    json: bool,
35
36    /// Show verbose output
37    #[arg(long, short = 'v')]
38    verbose: bool,
39
40    /// Timeout in seconds to wait before force kill
41    #[arg(long, short, default_value = "10")]
42    timeout: u64,
43
44    /// Filter by directory (defaults to current directory if no path given)
45    #[arg(long = "in", short = 'i', num_args = 0..=1, default_missing_value = ".")]
46    pub in_dir: Option<String>,
47
48    /// Filter by process name
49    #[arg(long = "by", short = 'b')]
50    pub by_name: Option<String>,
51
52    /// Initial signal to send instead of SIGTERM (e.g. HUP, USR1, INT)
53    #[arg(long, short = 'S')]
54    pub signal: Option<String>,
55}
56
57impl StopCommand {
58    /// Executes the stop command, gracefully terminating matched processes.
59    pub fn execute(&self) -> Result<()> {
60        let printer = Printer::from_flags(self.json, self.verbose);
61
62        // Validate --signal first, so a bad name fails the same way with or
63        // without --dry-run, and before the confirmation prompt
64        #[cfg(unix)]
65        let custom_signal = if let Some(ref sig_name) = self.signal {
66            Some(parse_signal_name(sig_name)?)
67        } else {
68            None
69        };
70        // Windows has no signals: say so rather than quietly sending a normal stop
71        #[cfg(not(unix))]
72        if self.signal.is_some() {
73            return Err(ProcError::InvalidInput(
74                "--signal is not supported on Windows (proc stop asks the process to exit)"
75                    .to_string(),
76            ));
77        }
78
79        // Parse comma-separated targets and resolve to processes
80        // Use resolve_targets_excluding_self to avoid stopping ourselves
81        let targets = parse_targets(&self.target);
82        let (mut processes, not_found) = resolve_targets_excluding_self(&targets);
83
84        // Warn about targets that weren't found
85        if !not_found.is_empty() {
86            printer.warning(&format!("Not found: {}", not_found.join(", ")));
87        }
88
89        // Apply --in and --by filters
90        apply_filters(&mut processes, &self.in_dir, &self.by_name);
91
92        if processes.is_empty() {
93            return Err(ProcError::ProcessNotFound(self.target.clone()));
94        }
95
96        // Dry run: just show what would be stopped
97        if self.dry_run {
98            printer.print_dry_run("stop", &processes);
99            return Ok(());
100        }
101
102        // Confirm if not --yes
103        if !printer.ask_confirm("stop", &processes, self.yes)? {
104            return Ok(());
105        }
106
107        // Stop processes
108        let mut stopped = Vec::new();
109        let mut failed = Vec::new();
110
111        for proc in &processes {
112            #[cfg(unix)]
113            let send_result = if let Some(signal) = custom_signal {
114                proc.send_signal(signal)
115            } else {
116                proc.terminate()
117            };
118            #[cfg(not(unix))]
119            let send_result = proc.terminate();
120
121            match send_result {
122                Ok(()) => {
123                    // Wait for process to exit
124                    let stopped_gracefully = self.wait_for_exit(proc);
125                    if stopped_gracefully {
126                        stopped.push(proc.clone());
127                    } else {
128                        // Force kill after timeout - use kill_and_wait for reliability
129                        match proc.kill_and_wait() {
130                            Ok(_) => stopped.push(proc.clone()),
131                            Err(e) => failed.push((proc.clone(), e.to_string())),
132                        }
133                    }
134                }
135                Err(e) => failed.push((proc.clone(), e.to_string())),
136            }
137        }
138
139        // Output results
140        printer.print_action_result("stop", &stopped, &failed)
141    }
142
143    fn wait_for_exit(&self, proc: &Process) -> bool {
144        let start = std::time::Instant::now();
145        let timeout = std::time::Duration::from_secs(self.timeout);
146
147        while start.elapsed() < timeout {
148            if !proc.is_running() {
149                return true;
150            }
151            std::thread::sleep(std::time::Duration::from_millis(100));
152        }
153
154        false
155    }
156}
proc_cli/commands/stop.rs

proc_cli/commands/
stop.rs
