fix(cli): Fix mixup of TAURI_APP_PATH and TAURI_FRONTEND_PATH

crates/tauri-cli/src/acl/permission/ls.rs

@@ -23,8 +23,7 @@ pub struct Options {
 pub fn command(options: Options) -> Result<()> {
   crate::helpers::app_paths::resolve();
 
-  let tauri_dir = tauri_dir();
-  let acl_manifests_path = tauri_dir
+  let acl_manifests_path = tauri_dir()
     .join("gen")
     .join("schemas")
     .join("acl-manifests.json");

crates/tauri-cli/src/add.rs

@@ -9,7 +9,7 @@ use regex::Regex;
 use crate::{
   acl,
   helpers::{
-    app_paths::{resolve_app_dir, tauri_dir},
+    app_paths::{resolve_frontend_dir, tauri_dir},
     cargo,
     npm::PackageManager,
   },
@@ -56,7 +56,7 @@ pub fn run(options: Options) -> Result<()> {
   let mut plugins = crate::helpers::plugins::known_plugins();
   let metadata = plugins.remove(plugin).unwrap_or_default();
 
-  let app_dir = resolve_app_dir();
+  let frontend_dir = resolve_frontend_dir();
   let tauri_dir = tauri_dir();
 
   let target_str = metadata
@@ -81,7 +81,7 @@ pub fn run(options: Options) -> Result<()> {
   })?;
 
   if !metadata.rust_only {
-    if let Some(manager) = app_dir
+    if let Some(manager) = frontend_dir
       .map(PackageManager::from_project)
       .and_then(|managers| managers.into_iter().next())
     {

crates/tauri-cli/src/dev.rs

@@ -4,7 +4,7 @@
 
 use crate::{
   helpers::{
-    app_paths::{app_dir, tauri_dir},
+    app_paths::{frontend_dir, tauri_dir},
     command_env,
     config::{
       get as get_config, reload as reload_config, BeforeDevCommand, ConfigHandle, FrontendDist,
@@ -140,7 +140,7 @@ pub fn setup(interface: &AppInterface, options: &mut Options, config: ConfigHand
         (Some(script), cwd.map(Into::into), wait)
       }
     };
-    let cwd = script_cwd.unwrap_or_else(|| app_dir().clone());
+    let cwd = script_cwd.unwrap_or_else(|| frontend_dir().clone());
     if let Some(before_dev) = script {
       log::info!(action = "Running"; "BeforeDevCommand (`{}`)", before_dev);
       let mut env = command_env(true);

crates/tauri-cli/src/helpers/app_paths.rs

@@ -18,12 +18,12 @@ use tauri_utils::{
 };
 
 const TAURI_GITIGNORE: &[u8] = include_bytes!("../../tauri.gitignore");
-// path to the Tauri app (Rust crate) directory, usually <cwd>/src-tauri
+// path to the Tauri app (Rust crate) directory, usually `<project>/src-tauri/`
 const ENV_TAURI_APP_PATH: &str = "TAURI_APP_PATH";
-// path to the frontend app directory
+// path to the frontend app directory, usually `<project>/`
 const ENV_TAURI_FRONTEND_PATH: &str = "TAURI_FRONTEND_PATH";
 
-static APP_DIR: OnceLock<PathBuf> = OnceLock::new();
+static FRONTEND_DIR: OnceLock<PathBuf> = OnceLock::new();
 static TAURI_DIR: OnceLock<PathBuf> = OnceLock::new();
 
 pub fn walk_builder(path: &Path) -> WalkBuilder {
@@ -90,7 +90,7 @@ fn env_tauri_frontend_path() -> Option<PathBuf> {
 }
 
 pub fn resolve_tauri_dir() -> Option<PathBuf> {
-  let src_dir = env_tauri_frontend_path().or_else(|| current_dir().ok())?;
+  let src_dir = env_tauri_app_path().or_else(|| current_dir().ok())?;
 
   if src_dir.join(ConfigFormat::Json.into_file_name()).exists()
     || src_dir.join(ConfigFormat::Json5.into_file_name()).exists()
@@ -113,16 +113,16 @@ pub fn resolve_tauri_dir() -> Option<PathBuf> {
 
 pub fn resolve() {
   TAURI_DIR.set(resolve_tauri_dir().unwrap_or_else(|| {
-    let env_var_name = env_tauri_frontend_path().is_some().then(|| format!("`{ENV_TAURI_FRONTEND_PATH}`"));
+    let env_var_name = env_tauri_app_path().is_some().then(|| format!("`{ENV_TAURI_APP_PATH}`"));
     panic!("Couldn't recognize the {} folder as a Tauri project. It must contain a `{}`, `{}` or `{}` file in any subfolder.",
       env_var_name.as_deref().unwrap_or("current"),
       ConfigFormat::Json.into_file_name(),
       ConfigFormat::Json5.into_file_name(),
       ConfigFormat::Toml.into_file_name()
     )
   })).expect("tauri dir already resolved");
-  APP_DIR
-    .set(resolve_app_dir().unwrap_or_else(|| tauri_dir().parent().unwrap().to_path_buf()))
+  FRONTEND_DIR
+    .set(resolve_frontend_dir().unwrap_or_else(|| tauri_dir().parent().unwrap().to_path_buf()))
     .expect("app dir already resolved");
 }
 
@@ -132,14 +132,15 @@ pub fn tauri_dir() -> &'static PathBuf {
     .expect("app paths not initialized, this is a Tauri CLI bug")
 }
 
-pub fn resolve_app_dir() -> Option<PathBuf> {
-  let app_dir = env_tauri_app_path().unwrap_or_else(|| current_dir().expect("failed to read cwd"));
+pub fn resolve_frontend_dir() -> Option<PathBuf> {
+  let frontend_dir =
+    env_tauri_frontend_path().unwrap_or_else(|| current_dir().expect("failed to read cwd"));
 
-  if app_dir.join("package.json").exists() {
-    return Some(app_dir);
+  if frontend_dir.join("package.json").exists() {
+    return Some(frontend_dir);
   }
 
-  lookup(&app_dir, |path| {
+  lookup(&frontend_dir, |path| {
     if let Some(file_name) = path.file_name() {
       file_name == OsStr::new("package.json")
     } else {
@@ -149,8 +150,8 @@ pub fn resolve_app_dir() -> Option<PathBuf> {
   .map(|p| p.parent().unwrap().to_path_buf())
 }
 
-pub fn app_dir() -> &'static PathBuf {
-  APP_DIR
+pub fn frontend_dir() -> &'static PathBuf {
+  FRONTEND_DIR
     .get()
     .expect("app paths not initialized, this is a Tauri CLI bug")
 }

crates/tauri-cli/src/helpers/mod.rs

@@ -31,7 +31,7 @@ use crate::{
   CommandExt,
 };
 
-use self::app_paths::app_dir;
+use self::app_paths::frontend_dir;
 
 pub fn command_env(debug: bool) -> HashMap<&'static str, String> {
   let mut map = HashMap::new();
@@ -80,7 +80,7 @@ pub fn run_hook(
     HookCommand::Script(s) => (Some(s), None),
     HookCommand::ScriptWithOptions { script, cwd } => (Some(script), cwd.map(Into::into)),
   };
-  let cwd = script_cwd.unwrap_or_else(|| app_dir().clone());
+  let cwd = script_cwd.unwrap_or_else(|| frontend_dir().clone());
   if let Some(script) = script {
     log::info!(action = "Running"; "{} `{}`", name, script);
 

crates/tauri-cli/src/helpers/npm.rs

@@ -70,7 +70,11 @@ impl PackageManager {
     }
   }
 
-  pub fn install<P: AsRef<Path>>(&self, dependencies: &[String], app_dir: P) -> crate::Result<()> {
+  pub fn install<P: AsRef<Path>>(
+    &self,
+    dependencies: &[String],
+    frontend_dir: P,
+  ) -> crate::Result<()> {
     let dependencies_str = if dependencies.len() > 1 {
       "dependencies"
     } else {
@@ -89,7 +93,7 @@ impl PackageManager {
       .cross_command()
       .arg("add")
       .args(dependencies)
-      .current_dir(app_dir)
+      .current_dir(frontend_dir)
       .status()
       .with_context(|| format!("failed to run {self}"))?;
 
@@ -100,7 +104,11 @@ impl PackageManager {
     Ok(())
   }
 
-  pub fn remove<P: AsRef<Path>>(&self, dependencies: &[String], app_dir: P) -> crate::Result<()> {
+  pub fn remove<P: AsRef<Path>>(
+    &self,
+    dependencies: &[String],
+    frontend_dir: P,
+  ) -> crate::Result<()> {
     let dependencies_str = if dependencies.len() > 1 {
       "dependencies"
     } else {
@@ -123,7 +131,7 @@ impl PackageManager {
         "remove"
       })
       .args(dependencies)
-      .current_dir(app_dir)
+      .current_dir(frontend_dir)
       .status()
       .with_context(|| format!("failed to run {self}"))?;
 
@@ -137,15 +145,15 @@ impl PackageManager {
   pub fn current_package_version<P: AsRef<Path>>(
     &self,
     name: &str,
-    app_dir: P,
+    frontend_dir: P,
   ) -> crate::Result<Option<String>> {
     let (output, regex) = match self {
       PackageManager::Yarn => (
         cross_command("yarn")
           .args(["list", "--pattern"])
           .arg(name)
           .args(["--depth", "0"])
-          .current_dir(app_dir)
+          .current_dir(frontend_dir)
           .output()?,
         None,
       ),
@@ -154,7 +162,7 @@ impl PackageManager {
           .arg("info")
           .arg(name)
           .arg("--json")
-          .current_dir(app_dir)
+          .current_dir(frontend_dir)
           .output()?,
         Some(regex::Regex::new("\"Version\":\"([\\da-zA-Z\\-\\.]+)\"").unwrap()),
       ),
@@ -163,7 +171,7 @@ impl PackageManager {
           .arg("list")
           .arg(name)
           .args(["--parseable", "--depth", "0"])
-          .current_dir(app_dir)
+          .current_dir(frontend_dir)
           .output()?,
         None,
       ),
@@ -173,7 +181,7 @@ impl PackageManager {
           .arg("list")
           .arg(name)
           .args(["version", "--depth", "0"])
-          .current_dir(app_dir)
+          .current_dir(frontend_dir)
           .output()?,
         None,
       ),

crates/tauri-cli/src/info/app.rs

@@ -10,7 +10,7 @@ use std::{
 };
 use tauri_utils::platform::Target;
 
-pub fn items(app_dir: Option<&PathBuf>, tauri_dir: Option<&Path>) -> Vec<SectionItem> {
+pub fn items(frontend_dir: Option<&PathBuf>, tauri_dir: Option<&Path>) -> Vec<SectionItem> {
   let mut items = Vec::new();
   if tauri_dir.is_some() {
     if let Ok(config) = crate::helpers::config::get(Target::current(), None) {
@@ -41,8 +41,8 @@ pub fn items(app_dir: Option<&PathBuf>, tauri_dir: Option<&Path>) -> Vec<Section
         items.push(SectionItem::new().description(format!("devUrl: {dev_url}")));
       }
 
-      if let Some(app_dir) = app_dir {
-        if let Ok(package_json) = read_to_string(app_dir.join("package.json")) {
+      if let Some(frontend_dir) = frontend_dir {
+        if let Ok(package_json) = read_to_string(frontend_dir.join("package.json")) {
           let (framework, bundler) = framework::infer_from_package_json(&package_json);
 
           if let Some(framework) = framework {

crates/tauri-cli/src/info/mod.rs

@@ -2,7 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use crate::Result;
+use crate::{
+  helpers::app_paths::{resolve_frontend_dir, resolve_tauri_dir},
+  Result,
+};
 use clap::Parser;
 use colored::{ColoredString, Colorize};
 use dialoguer::{theme::ColorfulTheme, Confirm};
@@ -258,15 +261,15 @@ pub struct Options {
 pub fn command(options: Options) -> Result<()> {
   let Options { interactive } = options;
 
-  let app_dir = crate::helpers::app_paths::resolve_app_dir();
-  let tauri_dir = crate::helpers::app_paths::resolve_tauri_dir();
+  let frontend_dir = resolve_frontend_dir();
+  let tauri_dir = resolve_tauri_dir();
 
   if tauri_dir.is_some() {
     // safe to initialize
     crate::helpers::app_paths::resolve();
   }
 
-  let package_manager = app_dir
+  let package_manager = frontend_dir
     .as_ref()
     .map(packages_nodejs::package_manager)
     .unwrap_or(crate::helpers::npm::PackageManager::Npm);
@@ -288,19 +291,20 @@ pub fn command(options: Options) -> Result<()> {
     interactive,
     items: Vec::new(),
   };
-  packages
-    .items
-    .extend(packages_rust::items(app_dir.as_ref(), tauri_dir.as_deref()));
+  packages.items.extend(packages_rust::items(
+    frontend_dir.as_ref(),
+    tauri_dir.as_deref(),
+  ));
   packages.items.extend(packages_nodejs::items(
-    app_dir.as_ref(),
+    frontend_dir.as_ref(),
     package_manager,
     &metadata,
   ));
 
   let mut plugins = Section {
     label: "Plugins",
     interactive,
-    items: plugins::items(app_dir.as_ref(), tauri_dir.as_deref(), package_manager),
+    items: plugins::items(frontend_dir.as_ref(), tauri_dir.as_deref(), package_manager),
   };
 
   let mut app = Section {
@@ -310,7 +314,7 @@ pub fn command(options: Options) -> Result<()> {
   };
   app
     .items
-    .extend(app::items(app_dir.as_ref(), tauri_dir.as_deref()));
+    .extend(app::items(frontend_dir.as_ref(), tauri_dir.as_deref()));
 
   environment.display();
   packages.display();

crates/tauri-cli/src/info/packages_nodejs.rs

@@ -76,8 +76,8 @@ pub fn npm_latest_version(pm: &PackageManager, name: &str) -> crate::Result<Opti
   }
 }
 
-pub fn package_manager(app_dir: &PathBuf) -> PackageManager {
-  let found = PackageManager::from_project(app_dir);
+pub fn package_manager(frontend_dir: &PathBuf) -> PackageManager {
+  let found = PackageManager::from_project(frontend_dir);
 
   if found.is_empty() {
     println!(
@@ -110,18 +110,18 @@ pub fn package_manager(app_dir: &PathBuf) -> PackageManager {
 }
 
 pub fn items(
-  app_dir: Option<&PathBuf>,
+  frontend_dir: Option<&PathBuf>,
   package_manager: PackageManager,
   metadata: &VersionMetadata,
 ) -> Vec<SectionItem> {
   let mut items = Vec::new();
-  if let Some(app_dir) = app_dir {
+  if let Some(frontend_dir) = frontend_dir {
     for (package, version) in [
       ("@tauri-apps/api", None),
       ("@tauri-apps/cli", Some(metadata.js_cli.version.clone())),
     ] {
-      let app_dir = app_dir.clone();
-      let item = nodejs_section_item(package.into(), version, app_dir, package_manager);
+      let frontend_dir = frontend_dir.clone();
+      let item = nodejs_section_item(package.into(), version, frontend_dir, package_manager);
       items.push(item);
     }
   }
@@ -132,13 +132,13 @@ pub fn items(
 pub fn nodejs_section_item(
   package: String,
   version: Option<String>,
-  app_dir: PathBuf,
+  frontend_dir: PathBuf,
   package_manager: PackageManager,
 ) -> SectionItem {
   SectionItem::new().action(move || {
     let version = version.clone().unwrap_or_else(|| {
       package_manager
-        .current_package_version(&package, &app_dir)
+        .current_package_version(&package, &frontend_dir)
         .unwrap_or_default()
         .unwrap_or_default()
     });

crates/tauri-cli/src/info/packages_rust.rs

@@ -13,10 +13,10 @@ use colored::Colorize;
 use std::fs::read_to_string;
 use std::path::{Path, PathBuf};
 
-pub fn items(app_dir: Option<&PathBuf>, tauri_dir: Option<&Path>) -> Vec<SectionItem> {
+pub fn items(frontend_dir: Option<&PathBuf>, tauri_dir: Option<&Path>) -> Vec<SectionItem> {
   let mut items = Vec::new();
 
-  if tauri_dir.is_some() || app_dir.is_some() {
+  if tauri_dir.is_some() || frontend_dir.is_some() {
     if let Some(tauri_dir) = tauri_dir {
       let manifest: Option<CargoManifest> =
         if let Ok(manifest_contents) = read_to_string(tauri_dir.join("Cargo.toml")) {