Kill process on exit

[anytechie]

Hi, thanks for this wonderful library. I want to know how to kill process started with use std::process::Command

This is my code to start tauri app as well as a flask server:

#![cfg_attr(
  all(not(debug_assertions), target_os = "windows"),
  windows_subsystem = "windows"
)]

use std::process::Command;
use std::os::windows::process::CommandExt;

#[tauri::command]
fn start_server() {
  Command::new("./app-x86_64-pc-windows-msvc.exe")
    .arg("8080")
    .creation_flags(0x08000000) // hide console window
    .spawn()
    .expect("Failed to start the server");
}

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      tauri::async_runtime::spawn(async move {
        start_server();
      });
      Ok(())
    })
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

[FabianLars]

Command.spawn() returns a Child. That child should be Send&Sync so you can move it around and store it quite easily. You can then call child.kill() to kill the process.
If we're talking about killing it on app exit you can use the CloseRequested and/or ExistRequested events for this, for an example see here.

For storing the child you can use stuff like once_cell or tauri's built-in State.

Alternatively if this is a sidecar you can use tauris built-in Command::new_sidecar instead which uses the same creation_flag under the hood. This would have the sideeffect of tauri automatically trying to clean up those spawned children on app exit, while still providing a similar interface so you can kill it yourself.

[ThatXliner]

I am using the JS/TS API, spawning a non-sidecar process via .spawn(). Either SvelteKit isn't running the cleanup on HMR or killing the process doesn't kill the children's processes.

[vipierozan99]

I'm having the same problem, the sidecar process is not getting killed after I exit the window:

#[derive(Default)]
struct Backend(Option<CommandChild>);

fn main() {
    let mut backend = Backend::default();

    tauri::Builder::default()
        .build(tauri::generate_context!())
        .expect("Error building app")
        .run(move |app_handle, event| match event {
            RunEvent::Ready => {
                let (_, child) = Command::new_sidecar("backend_server")
                    .expect("Failed to create `backend_server` binary command")
                    .spawn()
                    .expect("Failed to spawn backend sidecar");

                _ = backend.0.insert(child);
            }
            RunEvent::ExitRequested { api, .. } => {
                if let Some(child) = backend.0.take() {
                    child.kill().expect("Failed to shutdown backend.");
                    println!("Backend gracefully shutdown.")
                }
            }      
            _ => {}
        });
}

I can see the println! in the terminal after I close the window, so the child.kill() line must be running, but when I check the process is still running. On the other hand if I kill the application in the terminal with Ctrl + C, Tauri automatically kills the sidecar process.

tauri = { version = "1.0.5", features = ["http-all", "process-command-api"] }

[FabianLars]

See this issue #4949. It's a little trickyyy, normally the main sidecar process is supposed to clean up its own children, but unfortunately it's quite common that they don't do it, which is why imo we need to look into providing a way to do that in Tauri (either directly inside Tauri or by at least giving users a way to handle it manually).

[vipierozan99]

@FabianLars thank you for pointing to that issue, I am also using pyinstaller with a flask backend, and with the PR #4836 I was able to:

use std::process::Command as StdCommand;
use tauri::api::process::Command;

let mut command = StdCommand::from(
    Command::new_sidecar("backend_server")
        .expect("Failed to create `backend_server` binary command"),
    );

Then using the command_group crate:

// spawn
let child = command.group_spawn().expect("Failed to spawn backend sidecar");
// then kill all
child.kill().expect("Failed to shutdown backend.");

Which successfully kills both the pyinstaller bootloader and flask processes (tested on linux only, but should work on other platforms as well)

[TheBlindM]

@FabianLars thank you for pointing to that issue, I am also using pyinstaller with a flask backend, and with the PR #4836 I was able to:

use std::process::Command as StdCommand;
use tauri::api::process::Command;

let mut command = StdCommand::from(
    Command::new_sidecar("backend_server")
        .expect("Failed to create `backend_server` binary command"),
    );

Then using the command_group crate:

// spawn
let child = command.group_spawn().expect("Failed to spawn backend sidecar");
// then kill all
child.kill().expect("Failed to shutdown backend.");

Which successfully kills both the pyinstaller bootloader and flask processes (tested on linux only, but should work on other platforms as well)

Do you have the complete code or demo? , I want to start a java service in it

[CyberQin]

#![cfg_attr(
all(not(debug_assertions), target_os = "windows"),
windows_subsystem = "windows"
)]
mod functions;

use std::process::Command;
use std::sync::mpsc::{sync_channel, Receiver};
use std::sync::Mutex;
use std::thread;
use command_group::{CommandGroup, GroupChild};
use tauri::api::process::Command as TCommand;
use sysinfo::{Pid, ProcessExt, Signal, System, SystemExt};
use tauri::WindowEvent;


fn start_backend(receiver: Receiver<i32>) {
  let t = TCommand::new_sidecar("windxapi")
    .expect("启动API服务器失败");
  let mut group = Command::from(t).group_spawn().expect("启动API失败");
  thread::spawn(move || {
    loop{
      let mut s = receiver.recv();
      if s.unwrap()==-1 {
        group.kill().expect("关闭API失败");
      }
    }
  });
}

fn main() {
  let (tx,rx) = sync_channel(1);
  start_backend(rx);
  tauri::Builder::default()
    .on_window_event(move |event| match event.event() {
      WindowEvent::Destroyed => {
        println!("准备关闭后台API");
        tx.send(-1).expect("发送关闭信号失败");
        println!("已关闭后台API");
      }
      _ => {}
    })
    // .invoke_handler(tauri::generate_handler![start_backend,terminate_backend,terminate_pid])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

@TheBlindM

[giiyms]

Wow this seems way more complicated than I had imagined. Thanks for the code will see if I can get mine working like yours.

[VEADoc]

@CyberQin niubility bro.

[CyberQin]

Recently, i update the method, no need to use oncell crate and global variable.
tauri has a statemanager , so i write a APIManager struct to control the sidecar, then use the statemanager to hold the APIManager struct instance!
It still need use Arc<Mutex<Option>> to wrap the instance because of multiprocess memory visit. But it's more clear to handle it.

[trymbill]

@CyberQin, you wouldn't happen to have an example for this? I'm working on something similar and would love to see how you implemented the tauri state manager instead of the global TX/RX channels.

[CyberQin]

@trymbill

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

pub mod api_manager;
mod clipboards;

use api_manager::APIManager;
use std::sync::Mutex;
use tauri::{Manager, State, WindowEvent};

struct APIManagerState {
    api_manager_mutex: Mutex<APIManager>,
}

#[tauri::command]
fn start_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .start_backend();
    am
}

#[tauri::command]
fn stop_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .terminate_backend();
    am
}

#[tauri::command]
fn restart_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .restart_backend();
    am
}

fn main() {
    let api_manager = APIManager::new();
    let ams = APIManagerState {
        api_manager_mutex: Mutex::new(api_manager),
    };

    tauri::Builder::default()
        .manage(ams)
        .setup(move |app| {
            let am: State<APIManagerState> = app.state();
            #[cfg(not(debug_assertions))]
            am.api_manager_mutex
                .lock()
                .unwrap()
                .start_backend()
                .expect("backend start failed");
            Ok(())
        })
        .on_window_event(move |event| match event.event() {
            WindowEvent::Destroyed => {
                let am: State<APIManagerState> = event.window().state();
                am.api_manager_mutex
                    .lock()
                    .unwrap()
                    .terminate_backend()
                    .expect("");
            }
            _ => {}
        })
        .invoke_handler(tauri::generate_handler![
            start_server,
            stop_server,
            restart_server
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Pls note that： i changed pyinstaller to onedir mode ,so i need use TauriCommand::new not sidecar . If you have a onefile package, still use sidecar and use command_group crate to hold sidecar child.

use std::borrow::BorrowMut;
use std::process::{Child, Command};
use tauri::api::process::Command as TCommand;

pub struct APIManager {
    cmd: Command,
    child: Option<Child>,
    // api_process: Option<GroupChild>,
}

impl APIManager {
    pub fn new() -> APIManager {
        // let t = TCommand::new_sidecar("windxapi").expect("启动API服务器失败");
        let tt = TCommand::new("./windx_api/windx_api");
        // let cmd_from_sidecar: Command = t.into();
        APIManager {
            cmd: tt.into(),
            child: None,
            // api_process: None,
        }
    }

    pub fn start_backend(&mut self) -> Result<String, String> {
        match self.child.borrow_mut() {
            Some(_) => {
                let info = "API服务子进程不为空，不再新建";
                println!("{}", &info);
                Ok(info.into())
            }
            None => {
                let child = self.cmd.spawn();
                match child {
                    Ok(v) => {
                        self.child = Some(v);
                        let info = "api start successful";
                        println!("{}", &info);
                        Ok(info.into())
                    }
                    Err(_) => {
                        let info = "api start failed";
                        println!("{}", &info);
                        Err(info.into())
                    }
                }
            }
        }     
    }

    pub fn terminate_backend(&mut self) -> Result<String, String> {
        match self.child.borrow_mut() {
            Some(child) => {
                // child.wait().expect("Some error happened when killing child process");
                child
                    .kill()
                    .expect("Some error happened when killing child process");
                self.child = None;
                let info = "Kill already existed child process then set it to None";
                println!("{}", &info);
                Ok(info.into())
            }
            _ => {
                let info = "API子进程当前不存在，无须操作";
                println!("{}", &info);
                Ok(info.into())
            }
        }
    }

    pub fn restart_backend(&mut self) -> Result<String, String> {
        let terminate_result = self.terminate_backend();
        match terminate_result {
            Ok(_) => {
                println!("已执行API终止动作");
                match self.start_backend() {
                    Ok(_) => {
                        let info = "重启API服务器成功";
                        println!("{}", &info);
                        Ok(info.into())
                    }
                    Err(e) => {
                        println!("{}", &e);
                        return Err(e.into());
                    }
                }
            }
            Err(e) => {
                println!("{}", &e);
                return Err(e);
            }
        }
    }
}

[NaCodermer]

I recommend using the kill binary.
It is the simplest solution I have found so far.

use std::process::{Child, Command};

fn kill_process(child: &mut Child) -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(unix)]
    {
        let pid = child.id().to_string();
        println!("Sending INT signal to process with PID: {}", pid);

        let mut kill = StdCommand::new("kill")
            .args(["-s", "SIGINT", &pid])
            .spawn()?;
        kill.wait()?;
    }

    #[cfg(windows)]
    {
        let pid = child.id().to_string();
        println!("Sending taskkill to process with PID: {}", pid);

        let mut kill = StdCommand::new("taskkill")
            .args(["/PID", &pid, "/F"])
            .spawn()?;
        kill.wait()?;
    }

    Ok(())
}

fn main() {
    let child = Command::new("your_process")
        .spawn()
        .expect("Failed to start process");

    // Simulate some work
    std::thread::sleep(std::time::Duration::from_secs(5));

    match kill_process(&child) {
        Ok(_) => println!("Process killed successfully."),
        Err(e) => eprintln!("Failed to kill process: {}", e),
    }
}

[NaCodermer]

your_process.sh

pids=()
./run.sh & # your real code here
pids+=($!) 

cleanup() {
    echo "Cleaning up..."
    for pid in "${pids[@]}"; do
        echo "Killing child process $pid"
        kill -s SIGINT "$pid" 2>/dev/null
        echo "$$: kill -s SIGINT $pid" >> cleanup.log
    done
    exit 0
}

trap cleanup SIGHUP SIGINT SIGQUIT SIGTERM
wait

[NaCodermer]

It's strange that this solution sometimes works very well, but when something like "node ./server/entry.fastify &" in "./run.sh" , sometimes it fails to close the "./run.sh"
only "your_process.sh" can always be closed
It seems like this is not a good idea

[NaCodermer]

Add the following code to the front of your_process.sh file

set -m 

when something like "node ./server/entry.fastify &" in "./run.sh", It also needs to have cleaning steps similar to the above in run.sh.

After doing this, all processes can be shut down.

Pay special attention to the fact that SIGINT is used in all places for successful testing.

[gschier]

This won't work on Windows, though

[NetOpWibby]

Thanks to #3273 (comment) and #7558 (comment) I found a solution.

commands.rs

fn kill_process(pid: &str) -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(unix)] {
        println!("Sending INT signal to process with PID: {}", pid);

        let mut kill = Command::new("kill")
            .args(["-s", "SIGINT", &pid])
            .spawn()?;
        kill.wait()?;
    }

    #[cfg(windows)] {
        println!("Sending taskkill to process with PID: {}", pid);

        let mut kill = StdCommand::new("taskkill")
            .args(["/PID", &pid, "/F"])
            .spawn()?;
        kill.wait()?;
    }

    Ok(())
}

#[tauri::command]
pub async fn quit_letsdane(pid: &str) -> Result<(), String> {
    match kill_process(pid) {
        Ok(_) => {
            println!("Process killed successfully.");
            Ok(())
        },
        Err(e) => {
            eprintln!("Failed to kill process: {}", e);
            Err(e.to_string())
        }
    }
}

#[tauri::command]
pub async fn start_letsdane(app: tauri::AppHandle) {
    let child = Command::new("/absolute/path/to/my/sidecar/executable-aarch64-apple-darwin")
        .args([
            "-r", "127.0.0.1:5350",
            "-addr", ":5555",
            "-skip-dnssec",
            "-skip-icann",
            "-conf", "/absolute/path/to/.config"
        ])
        .spawn()
        .expect("Failed to start process");

    let pid = child.id().to_string();
    app.emit("letsdane-pid", Payload { message: pid.to_string().into() }).unwrap();
}

main.rs

// ...
        .invoke_handler(tauri::generate_handler![
            commands::quit_letsdane,
            commands::start_letsdane
        ])
// ...

+page.svelte

  $: letsdanePID = 0;

  type Payload = {
    message: string;
  };

    const subMenu7 = await MenuItem.new({
      action: async() => {
        // TODO
        // : stop hnsd

        /// stop letsdane process
        await invoke("quit_letsdane", { pid: `${letsdanePID}` });

        await exit(0);
      },
      text: "Quit"
    });

  async function rustBackendListener() {
    await listen<Payload>("letsdane-pid", (event) => {
      console.log("Event triggered from rust!\nPayload: " + event.payload.message);
      letsdanePID = Number(event.payload.message);
      console.log(event.payload.message);
    });
  }

  onMount(async() => {
    await rustBackendListener();
    await invoke("start_letsdane");
    console.log(">>> letsdanePID", letsdanePID);
  });

My app will be open-source at some point but this is the gist.

[rangsaritv]

This seems to work for me in Tauri v2. Note that I use PyInstaller onefile which spawns 2 processes. Therefore, I also use STDIN to get some signal to terminate the other process.

use std::sync::{Arc, Mutex};
use tauri_plugin_shell::ShellExt;
use tauri::Manager;
use tauri::path::BaseDirectory;


#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_fs::init())
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet])
        .setup(|app| {

            let resource_path = app
            .path().resolve("resources/info.log", BaseDirectory::Resource)?;    

            let sidecar_command = app.shell().sidecar("client2").unwrap().args([resource_path]);
            let ( _rx, sidecar_child) = sidecar_command
              .spawn()
              .expect("Failed to spawn sidecar");

            // Wrap the child process in Arc<Mutex<>> for shared access
            let child = Arc::new(Mutex::new(Some(sidecar_child)));

            // Clone the Arc to move into the async task
            let child_clone = Arc::clone(&child);


            let window = app.get_webview_window("main").unwrap();

            window.on_window_event( move |event| {
              if let tauri::WindowEvent::CloseRequested { .. } = event {

                let mut child_lock = child_clone.lock().unwrap();
                if let Some(mut child_process) = child_lock.take() {
                  if let Err(e) = child_process.write("Exit message from Rust\n".as_bytes())
                  {
                    println!("Fail to send to stdin of Python: {}", e);
                  }

                  if let Err(e) = child_process.kill() {
                      eprintln!("Failed to kill child process: {}", e);
                  }
                }
              }
            });

            Ok(())

          })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

[akbarpn136]

It works nicely for Tauri V2, thank you

[yann-dubrana]

For anyone encountering the same issue, I’ve created a repository demonstrating a working solution. You can find it here: tauri-tensorflow-template. Feel free to explore the implementation, and I hope it helps! Feedback or suggestions are welcome.

[NetOpWibby]

Why not just link directly? https://github.com/yann-dubrana/tauri-tensorflow-template/blob/master/src-tauri/src/server.rs#L61-L70

[yann-dubrana]

Why not just link directly? https://github.com/yann-dubrana/tauri-tensorflow-template/blob/master/src-tauri/src/server.rs#L61-L70

i have made it this way to handle both onefile and multifile pyinstaller configuration. but i'm not an experienced rust developper so this is maybe bad design.

[hjg66-5]

thread 'main' panicked at src\lib.rs:72:61:
called Option::unwrap() on a None value
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace
[0626/064854.910:ERROR:ui\gfx\win\window_impl.cc:124] Failed to unregister class Chrome_WidgetWin_0. Error = 1412
error: process didn't exit successfully: target\debug\hula.exe (exit code: 101)

let window = app.get_webview_window("main").unwrap(); --- 这一行有问题

[kingwingfly]

In my solution, desc contains a Child process and will be killed when desc dropped.

        let desc = Arc::new(scrflow::TowerConfig::default().create());
        tauri::Builder::default()
            .manage(Arc::downgrade(&desc)) // Tauri does not drop managed states
            .invoke_handler(tauri::generate_handler![start, stop, terminate])
            .on_window_event(move |_, ev| {
                if matches!(ev, WindowEvent::Destroyed) {
                    let desc = Arc::clone(&desc);
                    let desc = Arc::into_raw(desc);

                    unsafe {
                        // Drop desc
                        Arc::decrement_strong_count(desc);
                        let _ = Arc::from_raw(desc);
                    }
                }
            })
            .run(tauri::generate_context!())
            .expect("error while running tauri application");

[elibroftw]

In tauri v2 for Music Caster's rewrite that I'm working on, I created my own sidecar utility file that uses the sysinfo crate. I can confirm on Windows that the sidecar properly starts and exits including child processes which my app uses due to the architecture.

There were three major obstacles in coming to this code. The first was figuring out how to manage state, which is easy once you decipher that you need mutability (i.e. wrap any struct that requires mutability with a Mutex). The second, which is harder, is that the child process is being killed, meaning that you need to somehow turn a Something into a Nothing. To "solve" this, you can just state that the child is an Option, which makes sense if you think about how the program could theoretically continue even after the child is killed. Thus, we use take when we want to kill the child. The third problem is that even if you kill the child process, its daemon child processes are still going untouched. Now one could argue that's a skill issue and that the binary should be propagating the exit event to its children, but I didn't have that implemented. So we need a cross-platform way to kill children. In windows, we could just use taskkill. If there was a straightforward way to kill trees in Linux and macOS, we could drop the sysinfo dependency.

mod sidecar_utils;
use crate::sidecar_utils::{MusicCasterDaemon, SidecarProcess};


.setup(|app| {
let app_handle = app.handle().clone();
let process = SidecarProcess::<MusicCasterDaemon>::new(&app_handle)?;
app_handle.manage(process);
}
.build(tauri::generate_context!())
    .expect("error while building tauri application")
    .run(|_app_handle, event| match event {
      tauri::RunEvent::ExitRequested { api, .. } => {
        let mc_child_state = _app_handle.state::<Mutex<SidecarProcess<MusicCasterDaemon>>>();
        let _ = mc_child_state.inner().lock().unwrap().kill();
      }
      _ => {}
    });

sidecar_utils.rs

use std::collections::VecDeque;
use std::marker::PhantomData;
use std::sync::Mutex;
use sysinfo::{Pid, Signal, System};
use tauri::{self, Manager};
use tauri_plugin_shell::ShellExt;
use tauri_plugin_shell::process::{CommandChild, CommandEvent};

pub trait SidecarConfig {
  fn binary_name() -> &'static str;

  fn args(app_handle: &tauri::AppHandle) -> Vec<String>;
}

// TODO: create a SidecarManager that can manage spawning and despawning sidecars based on Enums
/// A generic wrapper for managing sidecar processes with automatic cleanup
/// Usage:
/// 	let process = SidecarProcess::<MusicCasterDaemon>::new(&app_handle)?;
#[derive(Debug)]
pub struct SidecarProcess<T: SidecarConfig> {
  child: Option<CommandChild>,
  _phantom: PhantomData<T>,
}

impl<T: SidecarConfig> SidecarProcess<T> {
  /// Create and spawn a new sidecar process
  pub fn new(app_handle: &tauri::AppHandle) -> Result<Mutex<Self>, String> {
    let sidecar_command = app_handle
      .shell()
      .sidecar(T::binary_name())
      .map_err(|e| format!("Failed to create sidecar command: {}", e))?
      .args(T::args(app_handle));

    let (mut rx, child) = sidecar_command
      .spawn()
      .map_err(|e| format!("Failed to spawn {}: {}", T::binary_name(), e))?;

    // Spawn async task to handle process output
    let binary_name = T::binary_name().to_string();
    tauri::async_runtime::spawn(async move {
      while let Some(event) = rx.recv().await {
        match event {
          CommandEvent::Stdout(line_bytes) => {
            let line = String::from_utf8_lossy(&line_bytes);
            log::info!("[{}] {}", binary_name, line);
          }
          CommandEvent::Stderr(line_bytes) => {
            let line = String::from_utf8_lossy(&line_bytes);
            log::error!("[{} Error] {}", binary_name, line);
          }
          CommandEvent::Error(err) => {
            log::error!("[{}] Error: {}", binary_name, err);
          }
          CommandEvent::Terminated(payload) => {
            log::info!("[{}] Terminated with code: {:?}", binary_name, payload.code);
            break;
          }
          _ => {}
        }
      }
    });

    Ok(Mutex::new(SidecarProcess {
      child: Some(child),
      _phantom: PhantomData,
    }))
  }

  /// Get the process ID of the sidecar
  pub fn pid(&self) -> Option<u32> {
    self.child.as_ref().map(|c| c.pid())
  }

  /// Kill the sidecar process and all its descendants
  pub fn kill(&mut self) -> Result<(), String> {
    if let Some(child) = self.child.take() {
      kill_process_tree(child.pid())
    } else {
      Ok(())
    }
  }
}

impl<T: SidecarConfig> Drop for SidecarProcess<T> {
  fn drop(&mut self) {
    if self.child.is_some() {
      let _ = self.kill();
    }
  }
}

fn kill_process_tree(pid: u32) -> Result<(), String> {
  let mut system = System::new_all();
  system.refresh_all();

  let root_pid = Pid::from_u32(pid);

  // Collect all descendant PIDs
  let to_kill = collect_descendants(&system, root_pid);

  // Kill all processes (children first, then parent)
  for &pid in &to_kill {
    if let Some(process) = system.process(pid) {
      process.kill_with(Signal::Kill);
    }
  }

  Ok(())
}

fn collect_descendants(system: &System, root_pid: Pid) -> VecDeque<Pid> {
  let mut descendants = VecDeque::new();
  let mut queue = VecDeque::new();
  queue.push_back(root_pid);

  while let Some(current_pid) = queue.pop_front() {
    descendants.push_front(current_pid);
    // Find all direct children of current_pid
    for (child_pid, process) in system.processes() {
      if let Some(parent_pid) = process.parent() {
        if parent_pid == current_pid {
          queue.push_back(*child_pid);
        }
      }
    }
  }
  descendants
}

pub struct MusicCasterDaemon {}

impl SidecarConfig for MusicCasterDaemon {
  fn binary_name() -> &'static str {
    "music-caster-daemon"
  }

  fn args(app_handle: &tauri::AppHandle) -> Vec<String> {
    let app_args: Vec<String> = std::env::args().skip(1).collect();

    let app_data_dir = app_handle
      .path()
      .app_data_dir()
      .map_err(|e| format!("Failed to get app data directory: {}", e))
      .unwrap();

    std::fs::create_dir_all(&app_data_dir)
      .map_err(|e| format!("Failed to create app data directory: {}", e))
      .unwrap();

    let db_path = app_data_dir.join("music_caster.db").display().to_string();
    let settings_path = app_data_dir.join("settings.json").display().to_string();

    log::info!("settings path: {}", &settings_path);
    log::info!("db_path: {}", &db_path);

    let mut sidecar_args = vec![
      "--db-path".to_string(),
      db_path,
      "--settings-path".to_string(),
      settings_path,
    ];
    sidecar_args.extend(app_args);
    sidecar_args
  }
}