tauri-workspace/tooling/cli/src/dev.rs

// Copyright 2019-2022 Tauri Programme within The Commons Conservancy
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: MIT

use crate::{
  helpers::{
    app_paths::{app_dir, tauri_dir},
    command_env,
    config::{get as get_config, reload as reload_config, AppUrl, BeforeDevCommand, WindowUrl},
  },
  interface::{AppInterface, DevProcess, ExitReason, Interface},
  CommandExt, Result,
};

use anyhow::{bail, Context};
use clap::{ArgAction, Parser};
use log::{error, info, warn};
use once_cell::sync::OnceCell;
use shared_child::SharedChild;

use std::{
  env::set_current_dir,
  net::{IpAddr, Ipv4Addr, SocketAddr},
  process::{exit, Command, ExitStatus, Stdio},
  sync::{
    atomic::{AtomicBool, Ordering},
    Arc, Mutex,
  },
};

static BEFORE_DEV: OnceCell<Mutex<Arc<SharedChild>>> = OnceCell::new();
static KILL_BEFORE_DEV_FLAG: OnceCell<AtomicBool> = OnceCell::new();

#[cfg(unix)]
const KILL_CHILDREN_SCRIPT: &[u8] = include_bytes!("../scripts/kill-children.sh");

pub const TAURI_DEV_WATCHER_GITIGNORE: &[u8] = include_bytes!("../tauri-dev-watcher.gitignore");

#[derive(Debug, Clone, Parser)]
#[clap(about = "Tauri dev", trailing_var_arg(true))]
pub struct Options {
  /// Binary to use to run the application
  #[clap(short, long)]
  pub runner: Option<String>,
  /// Target triple to build against
  #[clap(short, long)]
  pub target: Option<String>,
  /// List of cargo features to activate
  #[clap(short, long, action = ArgAction::Append, num_args(0..))]
  pub features: Option<Vec<String>>,
  /// Exit on panic
  #[clap(short, long)]
  pub exit_on_panic: bool,
  /// JSON string or path to JSON file to merge with tauri.conf.json
  #[clap(short, long)]
  pub config: Option<String>,
  /// Run the code in release mode
  #[clap(long = "release")]
  pub release_mode: bool,
  /// Command line arguments passed to the runner. Arguments after `--` are passed to the application.
  pub args: Vec<String>,
  /// Disable the file watcher
  #[clap(long)]
  pub no_watch: bool,
  /// Disable the dev server for static files.
  #[clap(long)]
  pub no_dev_server: bool,
}

pub fn command(options: Options) -> Result<()> {
  let r = command_internal(options);
  if r.is_err() {
    kill_before_dev_process();
    #[cfg(not(debug_assertions))]
    let _ = check_for_updates();
  }
  r
}

fn command_internal(mut options: Options) -> Result<()> {
  let mut interface = setup(&mut options, false)?;
  let exit_on_panic = options.exit_on_panic;
  let no_watch = options.no_watch;
  interface.dev(options.into(), move |status, reason| {
    on_app_exit(status, reason, exit_on_panic, no_watch)
  })
}

fn local_ip_address() -> &'static IpAddr {
  static LOCAL_IP: OnceCell<IpAddr> = OnceCell::new();
  LOCAL_IP.get_or_init(|| {
    let addresses: Vec<IpAddr> = local_ip_address::list_afinet_netifas()
      .expect("failed to list networks")
      .into_iter()
      .map(|(_, ipaddr)| ipaddr)
      .filter(|ipaddr| match ipaddr {
        IpAddr::V4(i) => i != &Ipv4Addr::LOCALHOST,
        _ => false,
      })
      .collect();
    match addresses.len() {
      0 => panic!("No external IP detected."),
      1 => {
        let ipaddr = addresses.first().unwrap();
        log::info!("Detected external IP {ipaddr}.");
        *ipaddr
      }
      _ => {
        let selected = dialoguer::Select::with_theme(&dialoguer::theme::ColorfulTheme::default())
          .with_prompt("What external IP should we use for your development server?")
          .items(&addresses)
          .default(0)
          .interact()
          .expect("failed to select external IP");
        *addresses.get(selected).unwrap()
      }
    }
  })
}

pub fn setup(options: &mut Options, mobile: bool) -> Result<AppInterface> {
  let tauri_path = tauri_dir();
  options.config = if let Some(config) = &options.config {
    Some(if config.starts_with('{') {
      config.to_string()
    } else {
      std::fs::read_to_string(config).with_context(|| "failed to read custom configuration")?
    })
  } else {
    None
  };

  set_current_dir(tauri_path).with_context(|| "failed to change current working directory")?;

  let config = get_config(options.config.as_deref())?;

  let interface = AppInterface::new(
    config.lock().unwrap().as_ref().unwrap(),
    options.target.clone(),
  )?;

  let mut dev_path = config
    .lock()
    .unwrap()
    .as_ref()
    .unwrap()
    .build
    .dev_path
    .clone();

  if mobile {
    if let AppUrl::Url(WindowUrl::External(url)) = &mut dev_path {
      let localhost = match url.host() {
        Some(url::Host::Domain(d)) => d == "localhost",
        Some(url::Host::Ipv4(i)) => {
          i == std::net::Ipv4Addr::LOCALHOST || i == std::net::Ipv4Addr::UNSPECIFIED
        }
        _ => false,
      };
      if localhost {
        let ip = local_ip_address();
        url.set_host(Some(&ip.to_string())).unwrap();
        if let Some(c) = &options.config {
          let mut c: tauri_utils::config::Config = serde_json::from_str(c)?;
          c.build.dev_path = dev_path.clone();
          options.config = Some(serde_json::to_string(&c).unwrap());
        } else {
          options.config = Some(format!(r#"{{ "build": {{ "devPath": "{}" }} }}"#, url))
        }
        reload_config(options.config.as_deref())?;
      }
    }
  }

  if let Some(before_dev) = config
    .lock()
    .unwrap()
    .as_ref()
    .unwrap()
    .build
    .before_dev_command
    .clone()
  {
    let (script, script_cwd, wait) = match before_dev {
      BeforeDevCommand::Script(s) if s.is_empty() => (None, None, false),
      BeforeDevCommand::Script(s) => (Some(s), None, false),
      BeforeDevCommand::ScriptWithOptions { script, cwd, wait } => {
        (Some(script), cwd.map(Into::into), wait)
      }
    };
    let cwd = script_cwd.unwrap_or_else(|| app_dir().clone());
    if let Some(mut before_dev) = script {
      if before_dev.contains("$HOST") {
        if mobile {
          let local_ip_address = local_ip_address().to_string();
          before_dev = before_dev.replace("$HOST", &local_ip_address);
          if let AppUrl::Url(WindowUrl::External(url)) = &mut dev_path {
            url.set_host(Some(&local_ip_address))?;
          }
        } else {
          before_dev = before_dev.replace(
            "$HOST",
            if let AppUrl::Url(WindowUrl::External(url)) = &dev_path {
              url.host_str().unwrap_or("0.0.0.0")
            } else {
              "0.0.0.0"
            },
          );
        }
      }
      info!(action = "Running"; "BeforeDevCommand (`{}`)", before_dev);
      let mut env = command_env(true);
      env.extend(interface.env());

      #[cfg(windows)]
      let mut command = {
        let mut command = Command::new("cmd");
        command
          .arg("/S")
          .arg("/C")
          .arg(&before_dev)
          .current_dir(cwd)
          .envs(env);
        command
      };
      #[cfg(not(windows))]
      let mut command = {
        let mut command = Command::new("sh");
        command
          .arg("-c")
          .arg(&before_dev)
          .current_dir(cwd)
          .envs(env);
        command
      };

      if wait {
        let status = command.piped().with_context(|| {
          format!(
            "failed to run `{}` with `{}`",
            before_dev,
            if cfg!(windows) { "cmd /S /C" } else { "sh -c" }
          )
        })?;
        if !status.success() {
          bail!(
            "beforeDevCommand `{}` failed with exit code {}",
            before_dev,
            status.code().unwrap_or_default()
          );
        }
      } else {
        command.stdin(Stdio::piped());
        command.stdout(os_pipe::dup_stdout()?);
        command.stderr(os_pipe::dup_stderr()?);

        let child = SharedChild::spawn(&mut command)
          .unwrap_or_else(|_| panic!("failed to run `{}`", before_dev));
        let child = Arc::new(child);
        let child_ = child.clone();

        std::thread::spawn(move || {
          let status = child_
            .wait()
            .expect("failed to wait on \"beforeDevCommand\"");
          if !(status.success() || KILL_BEFORE_DEV_FLAG.get().unwrap().load(Ordering::Relaxed)) {
            error!("The \"beforeDevCommand\" terminated with a non-zero status code.");
            exit(status.code().unwrap_or(1));
          }
        });

        BEFORE_DEV.set(Mutex::new(child)).unwrap();
        KILL_BEFORE_DEV_FLAG.set(AtomicBool::default()).unwrap();

        let _ = ctrlc::set_handler(move || {
          kill_before_dev_process();
          #[cfg(not(debug_assertions))]
          let _ = check_for_updates();
          exit(130);
        });
      }
    }
  }

  if options.runner.is_none() {
    options.runner = config
      .lock()
      .unwrap()
      .as_ref()
      .unwrap()
      .build
      .runner
      .clone();
  }

  let mut cargo_features = config
    .lock()
    .unwrap()
    .as_ref()
    .unwrap()
    .build
    .features
    .clone()
    .unwrap_or_default();
  if let Some(features) = &options.features {
    cargo_features.extend(features.clone());
  }

  if let AppUrl::Url(WindowUrl::App(path)) = &dev_path {
    use crate::helpers::web_dev_server::start_dev_server;
    if path.exists() {
      let ip = if mobile {
        *local_ip_address()
      } else {
        Ipv4Addr::new(127, 0, 0, 1).into()
      };
      let port = 1430;
      let server_address = SocketAddr::new(ip, port);
      let path = path.canonicalize()?;
      start_dev_server(server_address, path);
      let server_url = format!("http://{}", server_address);
      dev_path = AppUrl::Url(WindowUrl::External(server_url.parse().unwrap()));

      // TODO: in v2, use an env var to pass the url to the app context
      // or better separate the config passed from the cli internally and
      // config passed by the user in `--config` into to separate env vars
      // and the context merges, the user first, then the internal cli config
      if let Some(c) = &options.config {
        let mut c: tauri_utils::config::Config = serde_json::from_str(c)?;
        c.build.dev_path = dev_path.clone();
        options.config = Some(serde_json::to_string(&c).unwrap());
      } else {
        options.config = Some(format!(
          r#"{{ "build": {{ "devPath": "{}" }} }}"#,
          server_url
        ))
      }
    }

    reload_config(options.config.as_deref())?;
  }

  if std::env::var_os("TAURI_SKIP_DEVSERVER_CHECK") != Some("true".into()) {
    if let AppUrl::Url(WindowUrl::External(dev_server_url)) = dev_path {
      let host = dev_server_url
        .host()
        .unwrap_or_else(|| panic!("No host name in the URL"));
      let port = dev_server_url
        .port_or_known_default()
        .unwrap_or_else(|| panic!("No port number in the URL"));
      let addrs;
      let addr;
      let addrs = match host {
        url::Host::Domain(domain) => {
          use std::net::ToSocketAddrs;
          addrs = (domain, port).to_socket_addrs()?;
          addrs.as_slice()
        }
        url::Host::Ipv4(ip) => {
          addr = (ip, port).into();
          std::slice::from_ref(&addr)
        }
        url::Host::Ipv6(ip) => {
          addr = (ip, port).into();
          std::slice::from_ref(&addr)
        }
      };
      let mut i = 0;
      let sleep_interval = std::time::Duration::from_secs(2);
      let max_attempts = 90;
      loop {
        if std::net::TcpStream::connect(addrs).is_ok() {
          break;
        }
        if i % 3 == 1 {
          warn!(
            "Waiting for your frontend dev server to start on {}...",
            dev_server_url
          );
        }
        i += 1;
        if i == max_attempts {
          error!(
            "Could not connect to `{}` after {}s. Please make sure that is the URL to your dev server.",
            dev_server_url, i * sleep_interval.as_secs()
          );
          exit(1);
        }
        std::thread::sleep(sleep_interval);
      }
    }
  }

  Ok(interface)
}

pub fn wait_dev_process<
  C: DevProcess + Send + 'static,
  F: Fn(ExitStatus, ExitReason) + Send + Sync + 'static,
>(
  child: C,
  on_exit: F,
) {
  std::thread::spawn(move || {
    let status = child.wait().expect("failed to wait on app");
    on_exit(
      status,
      if child.manually_killed_process() {
        ExitReason::TriggeredKill
      } else {
        ExitReason::NormalExit
      },
    );
  });
}

pub fn on_app_exit(status: ExitStatus, reason: ExitReason, exit_on_panic: bool, no_watch: bool) {
  if no_watch
    || (!matches!(reason, ExitReason::TriggeredKill)
      && (exit_on_panic || matches!(reason, ExitReason::NormalExit)))
  {
    kill_before_dev_process();
    #[cfg(not(debug_assertions))]
    let _ = check_for_updates();
    exit(status.code().unwrap_or(0));
  }
}

#[cfg(not(debug_assertions))]
fn check_for_updates() -> Result<()> {
  if std::env::var_os("TAURI_SKIP_UPDATE_CHECK") != Some("true".into()) {
    let current_version = crate::info::cli_current_version()?;
    let current = semver::Version::parse(&current_version)?;

    let upstream_version = crate::info::cli_upstream_version()?;
    let upstream = semver::Version::parse(&upstream_version)?;
    if current < upstream {
      println!(
        "🚀 A new version of Tauri CLI is available! [{}]",
        upstream.to_string()
      );
    };
  }
  Ok(())
}

pub fn kill_before_dev_process() {
  if let Some(child) = BEFORE_DEV.get() {
    let child = child.lock().unwrap();
    KILL_BEFORE_DEV_FLAG
      .get()
      .unwrap()
      .store(true, Ordering::Relaxed);
    #[cfg(windows)]
    {
      let powershell_path = std::env::var("SYSTEMROOT").map_or_else(
        |_| "powershell.exe".to_string(),
        |p| format!("{p}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"),
      );
      let _ = Command::new(powershell_path)
      .arg("-NoProfile")
      .arg("-Command")
      .arg(format!("function Kill-Tree {{ Param([int]$ppid); Get-CimInstance Win32_Process | Where-Object {{ $_.ParentProcessId -eq $ppid }} | ForEach-Object {{ Kill-Tree $_.ProcessId }}; Stop-Process -Id $ppid -ErrorAction SilentlyContinue }}; Kill-Tree {}", child.id()))
      .status();
    }
    #[cfg(unix)]
    {
      use std::io::Write;
      let mut kill_children_script_path = std::env::temp_dir();
      kill_children_script_path.push("kill-children.sh");

      if !kill_children_script_path.exists() {
        if let Ok(mut file) = std::fs::File::create(&kill_children_script_path) {
          use std::os::unix::fs::PermissionsExt;
          let _ = file.write_all(KILL_CHILDREN_SCRIPT);
          let mut permissions = file.metadata().unwrap().permissions();
          permissions.set_mode(0o770);
          let _ = file.set_permissions(permissions);
        }
      }
      let _ = Command::new(&kill_children_script_path)
        .arg(child.id().to_string())
        .output();
    }
    let _ = child.kill();
  }
}