Update pin and install.

crates/cli/src/commands/install.rs

@@ -4,7 +4,7 @@ use crate::helpers::{create_progress_bar, disable_progress_bars};
 use crate::shell;
 use clap::Args;
 use miette::IntoDiagnostic;
-use proto_core::{load_tool, Id, PinTypeLegacy, Tool, UnresolvedVersionSpec};
+use proto_core::{load_tool, Id, PinType, Tool, UnresolvedVersionSpec};
 use proto_pdk_api::{InstallHook, SyncShellProfileInput, SyncShellProfileOutput};
 use starbase::{system, SystemResult};
 use starbase_styles::color;
@@ -61,10 +61,10 @@ async fn pin_version(
 
     // via `pin-latest` setting
     if initial_version.is_latest() {
-        let user_config = tool.proto.load_user_config()?;
+        let config = tool.proto.load_config()?;
 
-        if let Some(pin_type) = &user_config.pin_latest {
-            args.global = matches!(pin_type, PinTypeLegacy::Global);
+        if let Some(pin_type) = &config.settings.pin_latest {
+            args.global = matches!(pin_type, PinType::Global);
 
             return internal_pin(tool, &args, true).await;
         }

crates/cli/src/commands/install_all.rs

@@ -22,7 +22,8 @@ pub async fn install_all() {
 
     debug!("Detecting tool versions to install");
 
-    let mut versions = loader.tools_config.tools.clone();
+    let config = loader.proto.load_config()?;
+    let mut versions = config.versions.to_owned();
 
     for tool in &tools {
         if versions.contains_key(&tool.id) {
@@ -83,7 +84,7 @@ pub async fn install_all() {
 
     info!("Successfully installed tools");
 
-    if loader.proto.load_user_config()?.auto_clean {
+    if config.settings.auto_clean {
         info!("Auto-clean enabled, starting clean");
 
         internal_clean(&CleanArgs {

crates/cli/src/commands/pin.rs

@@ -1,5 +1,7 @@
+use std::collections::BTreeMap;
+
 use clap::Args;
-use proto_core::{load_tool, Id, Tool, ToolsConfig, UnresolvedVersionSpec, UserConfig};
+use proto_core::{load_tool, Id, ProtoConfigManager, Tool, UnresolvedVersionSpec};
 use starbase::{system, SystemResult};
 use starbase_styles::color;
 use tracing::{debug, info};
@@ -20,35 +22,31 @@ pub struct PinArgs {
 }
 
 pub async fn internal_pin(tool: &mut Tool, args: &PinArgs, link: bool) -> SystemResult {
-    if args.global {
-        let mut user_config = UserConfig::load()?;
-
-        let config = user_config.tools.entry(tool.id.clone()).or_default();
-        config.default_version = Some(args.spec.clone());
-
-        user_config.save()?;
-
-        debug!(
-            version = args.spec.to_string(),
-            config = ?user_config.path,
-            "Wrote the global version",
-        );
-
+    let dir = if args.global {
         // Create symlink to this new version
         if link {
             tool.symlink_bins(true).await?;
         }
+
+        &tool.proto.home
     } else {
-        let mut config = ToolsConfig::load()?;
-        config.tools.insert(args.id.clone(), args.spec.clone());
-        config.save()?;
+        &tool.proto.cwd
+    };
+
+    let mut config = ProtoConfigManager::load_from(dir)?;
+
+    config
+        .versions
+        .get_or_insert(BTreeMap::default())
+        .insert(args.id.clone(), args.spec.clone());
 
-        debug!(
-            version = args.spec.to_string(),
-            config = ?config.path,
-            "Wrote the local version",
-        );
-    }
+    let path = ProtoConfigManager::save_to(dir, config)?;
+
+    debug!(
+        version = args.spec.to_string(),
+        config = ?path,
+        "Pinned the version",
+    );
 
     Ok(())
 }

crates/cli/src/commands/run.rs

@@ -174,7 +174,9 @@ pub async fn run(args: ArgsRef<RunArgs>) -> SystemResult {
 
     // Check if installed or install
     if !tool.is_setup(&version).await? {
-        if !tool.proto.load_user_config()?.auto_install {
+        let config = tool.proto.load_config()?;
+
+        if !config.settings.auto_install {
             return Err(ProtoError::MissingToolForRun {
                 tool: tool.get_name().to_owned(),
                 version: version.to_string(),

crates/cli/src/error.rs

@@ -1,5 +1,5 @@
 use miette::Diagnostic;
-use proto_core::TOOLS_CONFIG_NAME;
+use proto_core::PROTO_CONFIG_NAME;
 use starbase_styles::{Style, Stylize};
 use std::path::PathBuf;
 use thiserror::Error;
@@ -17,7 +17,7 @@ pub enum ProtoCliError {
     #[diagnostic(code(proto::cli::missing_tools_config))]
     #[error(
 			"No {} has been found in current directory. Attempted to find at {}.",
-			TOOLS_CONFIG_NAME.style(Style::File),
+			PROTO_CONFIG_NAME.style(Style::File),
 			.path.style(Style::Path),
 		)]
     MissingToolsConfigInCwd { path: PathBuf },

crates/cli/src/helpers.rs

@@ -2,12 +2,11 @@ use futures::StreamExt;
 use indicatif::{ProgressBar, ProgressStyle};
 use miette::IntoDiagnostic;
 use proto_core::{
-    get_temp_dir, load_tool_from_locator, Id, ProtoEnvironment, ProtoError, Tool, ToolsConfig,
-    SCHEMA_PLUGIN_KEY,
+    get_temp_dir, load_tool_from_locator, Id, ProtoEnvironment, ProtoError, Tool, SCHEMA_PLUGIN_KEY,
 };
 use starbase_utils::fs;
 use std::cmp;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 use std::env;
 use std::io::Write;
 use std::path::PathBuf;
@@ -100,19 +99,12 @@ pub async fn load_configured_tools_with_filters(filter: HashSet<&Id>) -> miette:
 
 pub struct ToolsLoader {
     pub proto: Arc<ProtoEnvironment>,
-    pub tools_config: ToolsConfig,
 }
 
 impl ToolsLoader {
     pub fn new() -> miette::Result<Self> {
-        let proto = ProtoEnvironment::new()?;
-
-        let mut tools_config = ToolsConfig::load_upwards_from(&proto.cwd, false)?;
-        tools_config.inherit_builtin_plugins();
-
         Ok(Self {
-            proto: Arc::new(proto),
-            tools_config,
+            proto: Arc::new(ProtoEnvironment::new()?),
         })
     }
 
@@ -121,16 +113,11 @@ impl ToolsLoader {
     }
 
     pub async fn load_tools_with_filters(&self, filter: HashSet<&Id>) -> miette::Result<Vec<Tool>> {
-        let user_config = self.proto.load_user_config()?;
-
-        let mut plugins = HashMap::new();
-        plugins.extend(&user_config.plugins);
-        plugins.extend(&self.tools_config.plugins);
-
+        let config = self.proto.load_config()?;
         let mut futures = vec![];
         let mut tools = vec![];
 
-        for (id, locator) in plugins {
+        for (id, locator) in &config.plugins {
             if !filter.is_empty() && !filter.contains(id) {
                 continue;
             }

crates/core/src/proto.rs

@@ -1,6 +1,7 @@
 use crate::helpers::{get_home_dir, get_proto_home, is_offline};
 use crate::proto_config::ProtoConfigManager;
 use crate::user_config::UserConfig;
+use crate::ProtoConfig;
 use once_cell::sync::OnceCell;
 use std::collections::BTreeMap;
 use std::env;
@@ -60,7 +61,7 @@ impl ProtoEnvironment {
     }
 
     pub fn get_http_client(&self) -> miette::Result<&reqwest::Client> {
-        let config = self.load_config_manager()?.get_merged_config()?;
+        let config = self.load_config()?;
 
         self.http_client
             .get_or_try_init(|| create_http_client_with_options(&config.settings.http))
@@ -83,6 +84,10 @@ impl ProtoEnvironment {
         ])
     }
 
+    pub fn load_config(&self) -> miette::Result<&ProtoConfig> {
+        self.load_config_manager()?.get_merged_config()
+    }
+
     pub fn load_config_manager(&self) -> miette::Result<&ProtoConfigManager> {
         self.config_manager.get_or_try_init(|| {
             // Don't traverse passed the home directory,

crates/core/src/proto_config.rs

@@ -236,27 +236,27 @@ impl ProtoConfigManager {
     }
 
     #[tracing::instrument(skip_all)]
-    pub fn save_to(dir: &Path, config: PartialProtoConfig) -> miette::Result<()> {
-        fs::write_file_with_lock(
-            dir.join(PROTO_CONFIG_NAME),
-            toml::to_string_pretty(&config).into_diagnostic()?,
-        )?;
+    pub fn save_to(dir: &Path, config: PartialProtoConfig) -> miette::Result<PathBuf> {
+        let path = dir.join(PROTO_CONFIG_NAME);
+
+        fs::write_file_with_lock(&path, toml::to_string_pretty(&config).into_diagnostic()?)?;
 
-        Ok(())
+        Ok(path)
     }
 
     pub fn get_merged_config(&self) -> miette::Result<&ProtoConfig> {
         self.merged_config.get_or_try_init(|| {
-            let mut config = PartialProtoConfig::default();
+            let mut partial = PartialProtoConfig::default();
             let context = &();
 
             for file in self.files.values() {
-                config.merge(context, file.to_owned())?;
+                partial.merge(context, file.to_owned())?;
             }
 
-            let config = config.finalize(context)?;
+            let mut config = ProtoConfig::from_partial(partial.finalize(context)?);
+            config.inherit_builtin_plugins();
 
-            Ok(ProtoConfig::from_partial(config))
+            Ok(config)
         })
     }
 }

crates/core/src/tool.rs

@@ -433,7 +433,7 @@ impl Tool {
 
         resolver.with_manifest(&self.manifest);
 
-        let config = self.proto.load_config_manager()?.get_merged_config()?;
+        let config = self.proto.load_config()?;
 
         if let Some(tool_config) = config.tools.get(&self.id) {
             resolver.with_config(tool_config);

crates/core/src/version_detector.rs

@@ -120,7 +120,7 @@ pub async fn detect_version(
     );
 
     let config_manager = tool.proto.load_config_manager()?;
-    let config = config_manager.get_merged_config()?;
+    let config = tool.proto.load_config()?;
 
     let detected_version = match config.settings.detect_strategy {
         DetectStrategy::FirstAvailable => {