feat: improve concurrency safety, cross-platform support and dynamic versioning

This change introduces:
- File locking for shared state files using fs4
- Dynamic versioning with commit ID and build time via build.rs
- Cross-platform support for macOS and ARM architectures
- Session-specific environment updates using PVM_SHELL_PID
- Safety guards and silent removal of temp files in shell wrappers
- Centralized constants and semantic version sorting logic
- Bug fixes in interactive menu and shell file discovery

Author: Fahl-Design

Cargo.lock

@@ -18,22 +18,21 @@ dialoguer = "0.12.0"
 dirs = "6.0.0"
 env_logger = "0.11.9"
 flate2 = "1.1.9"
+fs4 = "0.13.1"
+futures-util = "0.3.32"
 indicatif = "0.18.4"
-log = "0.4.29"
-regex = "1.12.3"
-reqwest = { version = "0.13.2", features = ["stream", "rustls"] }
-scraper = "0.25.0"
+reqwest = { version = "0.13.2", features = ["stream", "rustls", "json"] }
+semver = "1.0.27"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 tar = "0.4.44"
-thiserror = "2.0.18"
-tokio = { version = "1.49.0", features = ["full"] }
+tokio = { version = "1.50.0", features = ["full"] }
 
 [dev-dependencies]
 assert_cmd = "2.1.2"
 mockito = "1.7.2"
 predicates = "3.1.4"
-tempfile = "3.25.0"
+tempfile = "3.26.0"
 
 # Optimize for binary size and performance
 [profile.release]

Cargo.toml

@@ -0,0 +1,37 @@
+use std::process::Command;
+
+fn main() {
+    let commit_hash = Command::new("git")
+        .args(&["rev-parse", "--short", "HEAD"])
+        .output()
+        .ok()
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .map(|s| s.trim().to_string())
+        .unwrap_or_else(|| "unknown".to_string());
+
+    let build_time = Command::new("date")
+        .args(&["-u", "+%Y-%m-%dT%H:%M:%SZ"])
+        .output()
+        .ok()
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .map(|s| s.trim().to_string())
+        .unwrap_or_else(|| "unknown".to_string());
+    
+    let is_ci = std::env::var("GITHUB_ACTIONS").is_ok();
+    
+    let version = if is_ci {
+        let tag = Command::new("git")
+            .args(&["describe", "--tags", "--always"])
+            .output()
+            .ok()
+            .and_then(|output| String::from_utf8(output.stdout).ok())
+            .map(|s| s.trim().to_string())
+            .unwrap_or_else(|| "unknown".to_string());
+        format!("{} (built at: {})", tag, build_time)
+    } else {
+        let pkg_version = std::env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.0.0".to_string());
+        format!("{} (commit: {}, built at: {})", pkg_version, commit_hash, build_time)
+    };
+
+    println!("cargo:rustc-env=PVM_VERSION={}", version);
+}

build.rs

@@ -5,7 +5,7 @@ use clap::{Parser, Subcommand};
 #[derive(Parser)]
 #[command(
     name = "pvm",
-    version = env!("CARGO_PKG_VERSION"),
+    version = env!("PVM_VERSION"),
     author,
     about = "Fast and simple PHP version manager",
     disable_version_flag = true,

src/cli.rs

@@ -1,3 +1,4 @@
+use crate::constants::PVM_DIR_VAR;
 use crate::shell;
 use anyhow::Result;
 use clap::Parser;
@@ -18,13 +19,15 @@ pub struct Env {
 
 impl Env {
     pub async fn call(self) -> Result<()> {
+        let pvm_dir = crate::fs::get_pvm_dir()?;
         let s: Box<dyn shell::Shell> = match self.shell.as_deref() {
             Some("bash") => Box::new(shell::Bash),
             Some("zsh") => Box::new(shell::Zsh),
             Some("fish") => Box::new(shell::Fish),
             _ => shell::detect_shell(),
         };
 
+        println!("{}", s.set_env_var(PVM_DIR_VAR, &pvm_dir.to_string_lossy()));
         println!("{}", s.wrapper_fn());
         println!("{}", s.use_on_cd());
 

src/commands/env.rs

@@ -1,7 +1,10 @@
+use crate::constants::MULTISHELL_PATH_VAR;
 use crate::{fs, network};
 use anyhow::Result;
 use clap::Parser;
 use colored::Colorize;
+use fs4::fs_std::FileExt;
+use std::io::Write;
 
 /// Install a specific PHP version
 #[derive(Parser, Debug)]
@@ -72,23 +75,33 @@ pub async fn execute_install(version: &str) -> Result<()> {
                         if let Ok(bin_dir) = crate::fs::get_version_bin_dir(&v) {
                             let s = crate::shell::detect_shell();
                             let export_str1 =
-                                s.set_env_var("PVM_MULTISHELL_PATH", &bin_dir.to_string_lossy());
+                                s.set_env_var(MULTISHELL_PATH_VAR, &bin_dir.to_string_lossy());
                             let export_str2 = s.path(&bin_dir);
 
-                            if let Ok(pvm_dir) = crate::fs::get_pvm_dir() {
-                                let env_file = pvm_dir.join(".env_update");
-                                std::fs::write(
-                                    &env_file,
-                                    format!("{}\n{}", export_str1, export_str2),
-                                )
-                                .ok();
+                            if let Ok(env_file) = crate::fs::get_env_update_path() {
+                                // Atomic write with advisory lock
+                                if let Ok(file) = std::fs::OpenOptions::new()
+                                    .create(true)
+                                    .write(true)
+                                    .truncate(true)
+                                    .open(&env_file) 
+                                {
+                                    file.lock_exclusive().ok();
+                                    let mut writer = std::io::BufWriter::new(&file);
+                                    writeln!(writer, "{}\n{}", export_str1, export_str2).ok();
+                                    writer.flush().ok();
+                                    file.unlock().ok();
+                                }
                             }
 
                             unsafe {
-                                std::env::set_var("PVM_MULTISHELL_PATH", &bin_dir);
+                                std::env::set_var(MULTISHELL_PATH_VAR, &bin_dir);
                                 if let Some(path) = std::env::var_os("PATH") {
                                     let mut new_path = std::ffi::OsString::new();
                                     new_path.push(&bin_dir);
+                                    #[cfg(windows)]
+                                    new_path.push(";");
+                                    #[cfg(not(windows))]
                                     new_path.push(":");
                                     new_path.push(&path);
                                     std::env::set_var("PATH", new_path);

src/commands/install.rs

@@ -1,8 +1,11 @@
+use crate::constants::{MULTISHELL_PATH_VAR, PHP_VERSION_FILE};
 use crate::{fs, shell, update};
 use anyhow::Result;
 use clap::Parser;
 use colored::Colorize;
-use dialoguer::{Confirm, Select, theme::ColorfulTheme};
+use dialoguer::{theme::ColorfulTheme, Confirm, Select};
+use fs4::fs_std::FileExt;
+use std::io::Write;
 use std::path::Path;
 
 /// Change PHP version
@@ -71,12 +74,13 @@ impl Use {
         }
 
         // Smart prompt logic
-        if Path::new(".php-version").exists()
-            && let Ok(current_file_ver) = std::fs::read_to_string(".php-version")
+        if Path::new(PHP_VERSION_FILE).exists()
+            && let Ok(current_file_ver) = std::fs::read_to_string(PHP_VERSION_FILE)
             && current_file_ver.trim() != version
         {
             let prompt = format!(
-                "A .php-version file is present ({}). Do you want to apply this change to the directory?",
+                "A {} file is present ({}). Do you want to apply this change to the directory?",
+                PHP_VERSION_FILE,
                 current_file_ver.trim().yellow()
             );
             if Confirm::with_theme(&ColorfulTheme::default())
@@ -85,28 +89,42 @@ impl Use {
                 .interact_opt()?
                 .unwrap_or(false)
             {
-                std::fs::write(".php-version", &version).ok();
-                eprintln!("{} Updated .php-version to {}", "✓".green(), version.bold());
+                std::fs::write(PHP_VERSION_FILE, &version).ok();
+                eprintln!("{} Updated {} to {}", "✓".green(), PHP_VERSION_FILE, version.bold());
             }
         }
 
         let bin_dir = fs::get_version_bin_dir(&version)?;
         let s = shell::detect_shell();
 
         // These evaluate in the user's shell hook via wrapper
-        let export_str1 = s.set_env_var("PVM_MULTISHELL_PATH", &bin_dir.to_string_lossy());
+        let export_str1 = s.set_env_var(MULTISHELL_PATH_VAR, &bin_dir.to_string_lossy());
         let export_str2 = s.path(&bin_dir);
 
-        let pvm_dir = fs::get_pvm_dir()?;
-        let env_file = pvm_dir.join(".env_update");
-        std::fs::write(&env_file, format!("{}\n{}", export_str1, export_str2)).ok();
+        let env_file = fs::get_env_update_path()?;
+
+        // Atomic write with advisory lock
+        let file = std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&env_file)?;
+        file.lock_exclusive()?;
+        let mut writer = std::io::BufWriter::new(&file);
+        writeln!(writer, "{}", export_str1)?;
+        writeln!(writer, "{}", export_str2)?;
+        writer.flush()?;
+        file.unlock()?;
 
         // Also update the current Rust binary's environment so spawned subs (or interactive loop) see it
         unsafe {
-            std::env::set_var("PVM_MULTISHELL_PATH", &bin_dir);
+            std::env::set_var(MULTISHELL_PATH_VAR, &bin_dir);
             if let Some(path) = std::env::var_os("PATH") {
                 let mut new_path = std::ffi::OsString::new();
                 new_path.push(&bin_dir);
+                #[cfg(windows)]
+                new_path.push(";");
+                #[cfg(not(windows))]
                 new_path.push(":");
                 new_path.push(&path);
                 std::env::set_var("PATH", new_path);

src/commands/use_cmd.rs

@@ -0,0 +1,20 @@
+/// The name of the environment variable used to store the path to the PVM installation.
+pub const PVM_DIR_VAR: &str = "PVM_DIR";
+
+/// The name of the environment variable used to store the path to the currently active PHP version's bin directory.
+pub const MULTISHELL_PATH_VAR: &str = "PVM_MULTISHELL_PATH";
+
+/// The name of the file used to store the environment variables to be updated in the shell.
+pub const ENV_UPDATE_FILE: &str = ".env_update";
+
+/// The name of the file used to store the remote versions cache.
+pub const REMOTE_CACHE_FILE: &str = "remote_cache.json";
+
+/// The name of the file used as a guard for the update check.
+pub const UPDATE_CHECK_GUARD_FILE: &str = ".update_check_guard";
+
+/// The name of the file used to store the PHP version for a directory.
+pub const PHP_VERSION_FILE: &str = ".php-version";
+
+/// The base URL for fetching available PHP versions.
+pub const BASE_URL: &str = "https://dl.static-php.dev/static-php-cli/common/";

src/constants.rs

@@ -1,3 +1,4 @@
+use crate::constants::{MULTISHELL_PATH_VAR, PVM_DIR_VAR};
 use anyhow::{Context, Result};
 use std::path::PathBuf;
 
@@ -8,7 +9,7 @@ pub struct VersionItem {
 }
 
 pub fn get_pvm_dir() -> Result<PathBuf> {
-    if let Ok(pvm_dir) = std::env::var("PVM_DIR") {
+    if let Ok(pvm_dir) = std::env::var(PVM_DIR_VAR) {
         return Ok(PathBuf::from(pvm_dir));
     }
     let home = dirs::data_local_dir().context("Could not find local data directory")?;
@@ -44,16 +45,12 @@ pub fn list_installed_versions() -> Result<Vec<String>> {
         }
     }
 
-    versions.sort_by(|a, b| {
-        let a_parts: Vec<u32> = a.split('.').filter_map(|s| s.parse().ok()).collect();
-        let b_parts: Vec<u32> = b.split('.').filter_map(|s| s.parse().ok()).collect();
-        a_parts.cmp(&b_parts)
-    });
+    crate::utils::sort_versions(&mut versions);
     Ok(versions)
 }
 
 pub fn get_current_version() -> String {
-    if let Ok(path) = std::env::var("PVM_MULTISHELL_PATH") {
+    if let Ok(path) = std::env::var(MULTISHELL_PATH_VAR) {
         let p = PathBuf::from(path);
         if let Some(parent) = p.parent()
             && let Some(name) = parent.file_name()
@@ -64,6 +61,17 @@ pub fn get_current_version() -> String {
     "system".to_string()
 }
 
+pub fn get_env_update_path() -> Result<PathBuf> {
+    let pvm_dir = get_pvm_dir()?;
+    let shell_pid = std::env::var("PVM_SHELL_PID").unwrap_or_default();
+    let filename = if shell_pid.is_empty() {
+        crate::constants::ENV_UPDATE_FILE.to_string()
+    } else {
+        format!("{}_{}", crate::constants::ENV_UPDATE_FILE, shell_pid)
+    };
+    Ok(pvm_dir.join(filename))
+}
+
 pub fn get_aliased_versions() -> Result<Vec<VersionItem>> {
     let mut installed = list_installed_versions()?;
     if installed.is_empty() {

src/fs.rs

@@ -1,10 +1,12 @@
 mod cli;
 mod commands;
+mod constants;
 mod fs;
 mod interactive;
 mod network;
 mod shell;
 mod update;
+mod utils;
 
 use anyhow::Result;
 use clap::Parser;