1#[allow(unused_imports)]
2use std::process::Command;
3
4use crate::state::modal::CascadeMode;
5
6#[must_use]
19pub fn check_config_directories(package_name: &str, home: &str) -> Vec<std::path::PathBuf> {
20 use std::path::PathBuf;
21 let mut found_dirs = Vec::new();
22
23 let home_pkg_dir = PathBuf::from(home).join(package_name);
25 if home_pkg_dir.exists() && home_pkg_dir.is_dir() {
26 found_dirs.push(home_pkg_dir);
27 }
28
29 let config_pkg_dir = PathBuf::from(home).join(".config").join(package_name);
31 if config_pkg_dir.exists() && config_pkg_dir.is_dir() {
32 found_dirs.push(config_pkg_dir);
33 }
34
35 found_dirs
36}
37
38#[cfg(not(target_os = "windows"))]
39use super::utils::{choose_terminal_index_prefer_path, command_on_path, shell_single_quote};
40
41#[cfg(not(target_os = "windows"))]
42fn configure_terminal_env(cmd: &mut Command, term: &str) {
55 if term == "konsole" && std::env::var_os("WAYLAND_DISPLAY").is_some() {
56 cmd.env("QT_LOGGING_RULES", "qt.qpa.wayland.textinput=false");
57 }
58 if term == "gnome-console" || term == "kgx" {
59 cmd.env("GSK_RENDERER", "cairo");
60 cmd.env("LIBGL_ALWAYS_SOFTWARE", "1");
61 }
62}
63
64#[cfg(not(target_os = "windows"))]
65fn configure_test_env(cmd: &mut Command) {
76 if let Ok(p) = std::env::var("PACSEA_TEST_OUT") {
77 if let Some(parent) = std::path::Path::new(&p).parent() {
78 let _ = std::fs::create_dir_all(parent);
79 }
80 cmd.env("PACSEA_TEST_OUT", p);
81 }
82}
83
84#[cfg(not(target_os = "windows"))]
85struct SpawnContext<'a> {
90 names_str: &'a str,
92 names_len: usize,
94 dry_run: bool,
96 cascade_mode: CascadeMode,
98}
99
100#[cfg(not(target_os = "windows"))]
101fn try_spawn_terminal(
118 term: &str,
119 args: &[&str],
120 needs_xfce_command: bool,
121 cmd_str: &str,
122 ctx: &SpawnContext<'_>,
123) -> bool {
124 let mut cmd = Command::new(term);
125 if needs_xfce_command && term == "xfce4-terminal" {
126 let quoted = shell_single_quote(cmd_str);
127 cmd.arg("--command").arg(format!("bash -lc {quoted}"));
128 } else {
129 cmd.args(args.iter().copied()).arg(cmd_str);
130 }
131 configure_test_env(&mut cmd);
132 configure_terminal_env(&mut cmd, term);
133
134 match cmd.spawn() {
135 Ok(_) => {
136 tracing::info!(
137 terminal = %term,
138 names = %ctx.names_str,
139 total = ctx.names_len,
140 dry_run = ctx.dry_run,
141 mode = ?ctx.cascade_mode,
142 "launched terminal for removal"
143 );
144 true
145 }
146 Err(e) => {
147 tracing::warn!(
148 terminal = %term,
149 error = %e,
150 names = %ctx.names_str,
151 "failed to spawn terminal, trying next"
152 );
153 false
154 }
155 }
156}
157
158#[cfg(not(target_os = "windows"))]
159pub fn spawn_remove_all(names: &[String], dry_run: bool, cascade_mode: CascadeMode) {
171 #[cfg(test)]
173 if std::env::var("PACSEA_TEST_OUT").is_err() {
174 return;
175 }
176
177 let names_str = names.join(" ");
178 tracing::info!(
179 names = %names_str,
180 total = names.len(),
181 dry_run = dry_run,
182 mode = ?cascade_mode,
183 "spawning removal"
184 );
185 let flag = cascade_mode.flag();
186 let hold_tail = "; echo; echo 'Finished.'; echo 'Press any key to close...'; read -rn1 -s _ || (echo; echo 'Press Ctrl+C to close'; sleep infinity)";
187 let tool = match crate::logic::privilege::active_tool() {
188 Ok(t) => t,
189 Err(err) => {
190 tracing::error!(error = %err, "privilege tool resolution failed for removal");
191 return;
192 }
193 };
194 let base = format!("pacman {flag} --noconfirm {}", names.join(" "));
195 let cmd_str = if dry_run {
196 let cmd = format!(
197 "{}{hold_tail}",
198 crate::logic::privilege::build_privilege_command(tool, &base)
199 );
200 let quoted = shell_single_quote(&cmd);
201 format!("echo DRY RUN: {quoted}")
202 } else {
203 format!(
204 "{}{hold_tail}",
205 crate::logic::privilege::build_privilege_command(tool, &base)
206 )
207 };
208
209 let terms_gnome_first: &[(&str, &[&str], bool)] = &[
210 ("gnome-terminal", &["--", "bash", "-lc"], false),
211 ("gnome-console", &["--", "bash", "-lc"], false),
212 ("kgx", &["--", "bash", "-lc"], false),
213 ("alacritty", &["-e", "bash", "-lc"], false),
214 ("ghostty", &["-e", "bash", "-lc"], false),
215 ("kitty", &["bash", "-lc"], false),
216 ("konsole", &["-e", "bash", "-lc"], false),
217 ("xterm", &["-hold", "-e", "bash", "-lc"], false),
218 ("xfce4-terminal", &[], true),
219 ("tilix", &["--", "bash", "-lc"], false),
220 ("mate-terminal", &["--", "bash", "-lc"], false),
221 ];
222 let terms_default: &[(&str, &[&str], bool)] = &[
223 ("alacritty", &["-e", "bash", "-lc"], false),
224 ("ghostty", &["-e", "bash", "-lc"], false),
225 ("kitty", &["bash", "-lc"], false),
226 ("konsole", &["-e", "bash", "-lc"], false),
227 ("gnome-terminal", &["--", "bash", "-lc"], false),
228 ("gnome-console", &["--", "bash", "-lc"], false),
229 ("kgx", &["--", "bash", "-lc"], false),
230 ("xterm", &["-hold", "-e", "bash", "-lc"], false),
231 ("xfce4-terminal", &[], true),
232 ("tilix", &["--", "bash", "-lc"], false),
233 ("mate-terminal", &["--", "bash", "-lc"], false),
234 ];
235
236 let is_gnome =
237 std::env::var("XDG_CURRENT_DESKTOP").is_ok_and(|v| v.to_uppercase().contains("GNOME"));
238 let terms = if is_gnome {
239 terms_gnome_first
240 } else {
241 terms_default
242 };
243
244 let ctx = SpawnContext {
245 names_str: &names_str,
246 names_len: names.len(),
247 dry_run,
248 cascade_mode,
249 };
250
251 let mut launched = choose_terminal_index_prefer_path(terms).is_some_and(|idx| {
252 let (term, args, needs_xfce_command) = terms[idx];
253 try_spawn_terminal(term, args, needs_xfce_command, &cmd_str, &ctx)
254 });
255
256 if !launched {
257 for (term, args, needs_xfce_command) in terms {
258 if command_on_path(term) {
259 launched = try_spawn_terminal(term, args, *needs_xfce_command, &cmd_str, &ctx);
260 if launched {
261 break;
262 }
263 }
264 }
265 }
266
267 if !launched {
268 let res = Command::new("bash").args(["-lc", &cmd_str]).spawn();
269 if let Err(e) = res {
270 tracing::error!(error = %e, names = %names_str, "failed to spawn bash to run removal command");
271 } else {
272 tracing::info!(
273 names = %names_str,
274 total = names.len(),
275 dry_run = dry_run,
276 mode = ?cascade_mode,
277 "launched bash for removal"
278 );
279 }
280 }
281}
282
283#[cfg(target_os = "windows")]
284#[allow(unused_variables, clippy::missing_const_for_fn)]
299pub fn spawn_remove_all(names: &[String], dry_run: bool, cascade_mode: CascadeMode) {
300 #[cfg(not(test))]
301 {
302 let mut names = names.to_vec();
303 if names.is_empty() {
304 names.push("nothing".into());
305 }
306 let names_str = names.join(" ");
307 let msg = if dry_run {
308 format!("DRY RUN: Would remove packages: {names_str}")
309 } else {
310 format!("Cannot remove packages on Windows: {names_str}")
311 };
312
313 if dry_run && super::utils::is_powershell_available() {
315 let escaped_msg = msg.replace('\'', "''");
317 let powershell_cmd = format!(
318 "Write-Host '{escaped_msg}' -ForegroundColor Yellow; Write-Host ''; Write-Host 'Press any key to close...'; $null = $Host.UI.RawUI.ReadKey('NoEcho,IncludeKeyDown')"
319 );
320 let _ = std::process::Command::new("powershell.exe")
321 .args(["-NoProfile", "-Command", &powershell_cmd])
322 .spawn();
323 } else {
324 let _ = std::process::Command::new("cmd")
325 .args([
326 "/C",
327 "start",
328 "Pacsea Remove",
329 "cmd",
330 "/K",
331 &super::utils::cmd_echo_command(&msg),
332 ])
333 .spawn();
334 }
335 }
336}
337
338#[cfg(test)]
339mod tests {
340 #[test]
341 #[cfg(unix)]
342 fn remove_all_uses_gnome_terminal_double_dash() {
354 use std::fs;
355 use std::os::unix::fs::PermissionsExt;
356 use std::path::PathBuf;
357
358 let mut dir: PathBuf = std::env::temp_dir();
359 dir.push(format!(
360 "pacsea_test_remove_gnome_{}_{}",
361 std::process::id(),
362 std::time::SystemTime::now()
363 .duration_since(std::time::UNIX_EPOCH)
364 .expect("System time is before UNIX epoch")
365 .as_nanos()
366 ));
367 let _ = fs::create_dir_all(&dir);
368 let mut out_path = dir.clone();
369 out_path.push("args.txt");
370 let mut term_path = dir.clone();
371 term_path.push("gnome-terminal");
372 let script = "#!/bin/sh\n: > \"$PACSEA_TEST_OUT\"\nfor a in \"$@\"; do printf '%s\n' \"$a\" >> \"$PACSEA_TEST_OUT\"; done\n";
373 fs::write(&term_path, script.as_bytes()).expect("failed to write test terminal script");
374 let mut perms = fs::metadata(&term_path)
375 .expect("failed to read test terminal script metadata")
376 .permissions();
377 perms.set_mode(0o755);
378 fs::set_permissions(&term_path, perms)
379 .expect("failed to set test terminal script permissions");
380
381 let orig_path = std::env::var_os("PATH");
382 unsafe {
383 std::env::set_var("PATH", dir.display().to_string());
384 std::env::set_var("PACSEA_TEST_OUT", out_path.display().to_string());
385 }
386
387 let names = vec!["ripgrep".to_string(), "fd".to_string()];
388 super::spawn_remove_all(
389 &names,
390 true,
391 crate::state::modal::CascadeMode::CascadeWithConfigs,
392 );
393 std::thread::sleep(std::time::Duration::from_millis(50));
394
395 let body = fs::read_to_string(&out_path).expect("fake terminal args file written");
396 let lines: Vec<&str> = body.lines().collect();
397 assert!(lines.len() >= 3, "expected at least 3 args, got: {body}");
398 assert_eq!(lines[0], "--");
399 assert_eq!(lines[1], "bash");
400 assert_eq!(lines[2], "-lc");
401
402 unsafe {
403 if let Some(v) = orig_path {
404 std::env::set_var("PATH", v);
405 } else {
406 std::env::remove_var("PATH");
407 }
408 std::env::remove_var("PACSEA_TEST_OUT");
409 }
410 }
411}