fix: issue with . base path in server

Author: dubadub

README.md

@@ -2,11 +2,11 @@
 
 CookCLI provides a suite of tools to create shopping lists and maintain recipes. We've built it to be simple and useful for automating your cooking and shopping routine with existing UNIX command line and scripting tools. It can also function as a webserver for your recipes, making them browsable on any device with a web browser.
 
-* [Example usage](#example-usage)  
-* [Installation](#installation)  
-* [Building from source](#building-from-source)  
-* [Contribution](#contribution)  
-* [License](#license)  
+* [Example usage](#example-usage)
+* [Installation](#installation)
+* [Building from source](#building-from-source)
+* [Contribution](#contribution)
+* [License](#license)
 
 ## Example usage
 
@@ -125,34 +125,38 @@ Run a web-server:
 You can find full documentation at https://cooklang.org/cli/help/ or by running `help` command.
 
 ```
-Usage: cook [OPTIONS] COMMAND
+A command-line interface for managing and working with Cooklang recipes
 
-Options:
-    -a, --aisle <aisle>             Specify an aisle.conf file to override shopping list default settings 
-    -u, --units <units>             Specify a units.conf file to override units default settings
-    -i, --inflection <inflection>   Specify an inflection.conf file to override default inflection settings
-    -h, --help                      Show help information.
+Usage: cook <COMMAND>
 
 Commands:
-    recipe                  Manage recipes and recipe files
-    shopping-list           Create a shopping list
-    server                  Run a webserver to serve your recipes on the web
-    fetch                   Pull recipes from the community recipe repository
-    version                 Show the CookCLI version information
-    help                    Show the help text for a sub-command
+  recipe         Manage recipe files
+  server         Run a webserver to serve your recipes on the web
+  shopping-list  Create a shopping list [aliases: sl]
+  seed           Populate directory with seed recipes
+  help           Print this message or the help of the given subcommand(s)
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
+
+Docs: https://cooklang.org/cli/help/
 ```
 
 ## Installation
 
 Download latest release for your platform from the [releases page](https://github.com/cooklang/CookCLI/releases) and add the file to your operating system's PATH.
 
-On Linux (or [WSL](https://docs.microsoft.com/en-us/windows/wsl/about)), this is easy. Simply extract the binary into your binaries folder with `sudo unzip CookCLI_1.0.0_linux_amd64.zip -d /usr/local/bin/` (note: you may need to install the unzip package first). 
+On Linux (or [WSL](https://docs.microsoft.com/en-us/windows/wsl/about)), this is easy. Simply extract the binary into your binaries folder (for example `/usr/local/bin/`).
 
 On MacOS:
 
     brew tap cooklang/tap
     brew install cooklang/tap/cook
 
+With Cargo:
+
+    cargo install cookcli
 
 ## Building from source
 

src/main.rs

@@ -36,7 +36,7 @@ use cooklang::Converter;
 use cooklang::CooklangParser;
 use cooklang::Extensions;
 use once_cell::sync::OnceCell;
-use std::path::Path;
+use crate::util::resolve_to_absolute_path;
 
 // commands
 mod recipe;
@@ -100,13 +100,15 @@ fn configure_context() -> Result<Context> {
         _ => Utf8PathBuf::from("."),
     };
 
-    if !base_path.is_dir() {
-        bail!("Base path is not a directory: {base_path}");
+    let absolute_base_path = resolve_to_absolute_path(&base_path)?;
+
+    if !absolute_base_path.is_dir() {
+        bail!("Base path is not a directory: {}", absolute_base_path);
     }
 
     Ok(Context {
         parser: OnceCell::new(),
-        base_path,
+        base_path: absolute_base_path,
     })
 }
 
@@ -127,15 +129,6 @@ fn configure_logging() {
         .init();
 }
 
-pub fn resolve_path(base_path: &Utf8Path, path: &Path) -> Utf8PathBuf {
-    let path = Utf8Path::from_path(path).expect(UTF8_PATH_PANIC);
-    if path.is_absolute() {
-        path.to_path_buf()
-    } else {
-        base_path.join(LOCAL_CONFIG_DIR).join(path)
-    }
-}
-
 pub fn global_file_path(name: &str) -> Result<Utf8PathBuf> {
     let dirs = directories::ProjectDirs::from("", "", APP_NAME)
         .context("Could not determine home directory path")?;

src/server/mod.rs

@@ -46,6 +46,7 @@ use std::{net::SocketAddr, sync::Arc};
 use tower_http::cors::CorsLayer;
 use tracing::info;
 use crate::util::split_recipe_name_and_scaling_factor;
+use crate::util::resolve_to_absolute_path;
 
 #[derive(Debug, Args)]
 pub struct ServerArgs {
@@ -127,14 +128,17 @@ fn build_state(ctx: Context, args: ServerArgs) -> Result<Arc<AppState>> {
     let parser = parser.into_inner().unwrap();
 
     let path = args.base_path.as_ref().unwrap_or(&base_path);
+    let absolute_path = resolve_to_absolute_path(path)?;
 
-    if path.is_file() {
-        bail!("Base path{} is not a directory", path);
+    if absolute_path.is_file() {
+        bail!("Base path {} is not a directory", absolute_path);
     }
 
+    tracing::info!("Using absolute base path: {:?}", absolute_path);
+
     Ok(Arc::new(AppState {
         parser,
-        base_path: path.clone(),
+        base_path: absolute_path,
         aisle_path,
     }))
 }
@@ -175,7 +179,7 @@ mod ui {
     }
 
     #[derive(RustEmbed)]
-    #[folder = "./ui/public/"]
+    #[folder = "ui/public/"]
     struct Assets;
 
     async fn static_ui(uri: Uri) -> impl axum::response::IntoResponse {
@@ -241,6 +245,7 @@ fn check_path(p: &str) -> Result<(), StatusCode> {
         .components()
         .all(|c| matches!(c, Utf8Component::Normal(_)))
     {
+        tracing::error!("Invalid path: {p}");
         return Err(StatusCode::BAD_REQUEST);
     }
     Ok(())
@@ -258,7 +263,10 @@ async fn shopping_list(
             .map(|(name, scaling_factor)| {
                 let target = scaling_factor
                     .parse::<f64>()
-                    .map_err(|_| StatusCode::BAD_REQUEST)?;
+                    .map_err(|_| {
+                        tracing::error!("Invalid scaling factor: {scaling_factor}");
+                        StatusCode::BAD_REQUEST
+                    })?;
                 Ok::<_, StatusCode>((name, target))
             })
             .unwrap_or(Ok((entry.as_str(), 1.0)))?;
@@ -304,9 +312,16 @@ async fn all_recipes(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     let recipes = cooklang_find::build_tree(&state.base_path)
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+        .map_err(|e| {
+            tracing::error!("Failed to build recipe tree: {:?}", e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
 
-    let recipes = serde_json::to_value(recipes).unwrap();
+    let recipes = serde_json::to_value(recipes)
+        .map_err(|e| {
+            tracing::error!("Failed to serialize recipes: {:?}", e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
 
     Ok(Json(recipes))
 }
@@ -329,10 +344,11 @@ async fn recipe(
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     check_path(&path)?;
 
-    let entry = cooklang_find::get_recipe(vec![&state.base_path], &Utf8PathBuf::from(path))
-        .map_err(|_| StatusCode::NOT_FOUND)?;
-
-    tracing::info!("Entry path: {:?}", entry.path());
+    let entry = cooklang_find::get_recipe(vec![&state.base_path], &Utf8PathBuf::from(&path))
+        .map_err(|_| {
+            tracing::error!("Recipe not found: {path}");
+            StatusCode::NOT_FOUND
+        })?;
 
     let recipe = entry.recipe(query.scale.unwrap_or(1.0));
 

src/util/mod.rs

@@ -35,6 +35,7 @@ pub mod cooklang_to_md;
 use anyhow::{Context as _, Result};
 
 use camino::Utf8Path;
+use camino::Utf8PathBuf;
 
 pub fn write_to_output<F>(output: Option<&Utf8Path>, f: F) -> Result<()>
 where
@@ -54,3 +55,36 @@ where
 pub fn split_recipe_name_and_scaling_factor(query: &str) -> Option<(&str, &str)> {
     query.trim().rsplit_once('@')
 }
+
+/// Resolves a path to an absolute path. If the input path is already absolute,
+/// it is returned as is. Otherwise, it is resolved relative to the current working directory.
+/// The path is normalized to remove any `.` or `..` components.
+pub fn resolve_to_absolute_path(path: &Utf8Path) -> anyhow::Result<Utf8PathBuf> {
+    let absolute = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|e| {
+                tracing::error!("Failed to get current directory: {:?}", e);
+                anyhow::anyhow!("Failed to get current directory")
+            })?
+            .join(path)
+            .try_into()
+            .map_err(|e| {
+                tracing::error!("Failed to convert path to UTF-8: {:?}", e);
+                anyhow::anyhow!("Failed to convert path to UTF-8")
+            })?
+    };
+
+    // Normalize the path by resolving all components
+    std::fs::canonicalize(&absolute)
+        .map_err(|e| {
+            tracing::error!("Failed to canonicalize path: {:?}", e);
+            anyhow::anyhow!("Failed to canonicalize path")
+        })?
+        .try_into()
+        .map_err(|e| {
+            tracing::error!("Failed to convert canonicalized path to UTF-8: {:?}", e);
+            anyhow::anyhow!("Failed to convert canonicalized path to UTF-8")
+        })
+}