Mountain/Binary/Extension/

ScanPathConfigure.rs

//! # Extension Scan Path Configure Module
//!
//! Configures extension scan paths from the executable directory.

use std::path::PathBuf;

use crate::{
	ApplicationState::State::ApplicationState::{ApplicationState, MapLockError},
	dev_log,
};

/// Configures extension scan paths by resolving paths from the executable
/// directory.
///
/// # Arguments
///
/// * `AppState` - The application state containing ExtensionScanPaths
///
/// # Returns
///
/// A `Result` indicating success or failure.
///
/// # Scan Path Configuration
///
/// This function adds the following default scan paths:
/// - `../Resources/extensions` - Bundled extensions in app resources directory
/// - `extensions` - Local extensions directory relative to executable
///
/// # Errors
///
/// Returns an error if ExtensionScanPaths mutex lock fails.
pub fn ScanPathConfigure(AppState:&std::sync::Arc<ApplicationState>) -> Result<Vec<PathBuf>, String> {
	dev_log!("extensions", "[Extensions] [ScanPaths] Locking ExtensionScanPaths...");

	let mut ScanPathsGuard = AppState
		.Extension
		.Registry
		.ExtensionScanPaths
		.lock()
		.map_err(MapLockError)
		.map_err(|e| format!("Failed to lock ExtensionScanPaths: {}", e))?;

	// Skip all built-in extensions when either the legacy
	// `Skip` or the `.env.Land.Extensions` flag
	// `Skip` is set. Both accepted so kernel /
	// minimal profiles and the skill-file env stay in sync. User scan path
	// still runs so VSIX-installed extensions remain visible.
	let SkipBuiltins = matches!(std::env::var("Skip").as_deref(), Ok("1") | Ok("true"))
		|| matches!(std::env::var("Skip").as_deref(), Ok("1") | Ok("true"));

	if SkipBuiltins {
		dev_log!(
			"extensions",
			"[Extensions] [ScanPaths] Skip=true - skipping all built-in paths, keeping user path"
		);
	} else {
		dev_log!("extensions", "[Extensions] [ScanPaths] Adding default scan paths...");
	}

	// `Ship` takes precedence over the executable-
	// relative probing chain. Useful for CI builds where the bundle layout
	// differs from both the `.app` convention and the repo layout.
	if !SkipBuiltins {
		if let Ok(Override) = std::env::var("Ship") {
			let OverridePath = ExpandUserPath(&Override);

			if OverridePath.exists() {
				dev_log!("extensions", "[Extensions] [ScanPaths] + {} (Ship)", OverridePath.display());

				ScanPathsGuard.push(OverridePath);
			} else {
				dev_log!(
					"extensions",
					"warn: [Extensions] [ScanPaths] Ship={} does not exist; ignoring",
					Override
				);
			}
		}
	}

	// Resolve paths from executable directory
	if !SkipBuiltins {
		if let Ok(ExecutableDirectory) = std::env::current_exe() {
			if let Some(Parent) = ExecutableDirectory.parent() {
				// Resolve `..` segments lexically (no filesystem access needed)
				// so log output is always clean even for non-existent paths.
				// Falls back to `std::fs::canonicalize` for existing paths to
				// also resolve symlinks.
				let Normalize = |P:std::path::PathBuf| -> std::path::PathBuf {
					if P.exists() {
						return P.canonicalize().unwrap_or(P);
					}
					let mut Out:Vec<std::path::Component> = Vec::new();
					for C in P.components() {
						match C {
							std::path::Component::ParentDir => {
								Out.pop();
							},
							_ => Out.push(C),
						}
					}
					Out.iter().collect()
				};

				// New canonical path: ../Resources/Static/Application/extensions.
				// Extensions land here when tauri.conf.json bundle.resources maps
				// them to "Static/Application/extensions" (single source layout).
				let StaticAppExtPath = Parent.join("../Resources/Static/Application/extensions");

				if StaticAppExtPath.exists() {
					let StaticAppExtPath = Normalize(StaticAppExtPath);
					dev_log!(
						"extensions",
						"[Extensions] [ScanPaths] + {} (Static/Application canonical)",
						StaticAppExtPath.display()
					);

					ScanPathsGuard.push(StaticAppExtPath);
				}

				// Legacy flat path: ../Resources/extensions (kept for backward
				// compat while the tauri.conf.json resources remap takes effect).
				let ResourcesPath = Normalize(Parent.join("../Resources/extensions"));

				dev_log!("extensions", "[Extensions] [ScanPaths] + {}", ResourcesPath.display());

				ScanPathsGuard.push(ResourcesPath);

				// VS Code-style bundle layout: `.app/Contents/Resources/app/extensions`.
				let ResourcesAppPath = Normalize(Parent.join("../Resources/app/extensions"));

				dev_log!("extensions", "[Extensions] [ScanPaths] + {}", ResourcesAppPath.display());

				ScanPathsGuard.push(ResourcesAppPath);

				// Debug/dev path: Target/debug/extensions
				let LocalPath = Parent.join("extensions");

				dev_log!("extensions", "[Extensions] [ScanPaths] + {}", LocalPath.display());

				ScanPathsGuard.push(LocalPath);

				// Monorepo-layout fallback paths: resolved relative to
				// `Element/Mountain/Target/{debug,release}/`, so they only
				// materialise when the binary runs from inside the repo.
				// Shipped `.app`s launched from `/Applications/` hit the
				// `.exists()` guard and silently skip - no need for a
				// `cfg(debug_assertions)` gate. Keeping these live in release
				// lets a raw `Target/release/<name>` launch find the same 98
				// built-in extensions a debug build does.
				//
				// Sky Target path: where CopyVSCodeAssets copies built-in
				// extensions during the Sky build.
				let SkyTargetPath = Parent.join("../../../Sky/Target/Static/Application/extensions");

				if SkyTargetPath.exists() {
					let SkyTargetPath = Normalize(SkyTargetPath);
					dev_log!(
						"extensions",
						"[Extensions] [ScanPaths] + {} (Sky Target, repo-layout)",
						SkyTargetPath.display()
					);

					ScanPathsGuard.push(SkyTargetPath);
				}

				// VS Code dependency path: built-in extensions from the VS
				// Code source checkout - avoids requiring a copy step.
				let DependencyPath = Parent.join("../../../../Dependency/Microsoft/Dependency/Editor/extensions");

				if DependencyPath.exists() {
					dev_log!(
						"extensions",
						"[Extensions] [ScanPaths] + {} (VS Code Dependency, repo-layout)",
						DependencyPath.display()
					);

					ScanPathsGuard.push(DependencyPath);
				}
			}
		}
	} // end !SkipBuiltins

	// User-scope paths: always scanned, independent of whether the binary
	// was launched from the repo, a `.app`, or a symlink on the Desktop.
	// Mirrors VS Code's `~/.vscode-oss/extensions` convention.
	//
	// Atom U1: `Lodge` overrides the default
	// `~/.fiddee/extensions`. Useful for per-workspace sandboxes, shared
	// caches on CI, or running against a test extensions set without
	// polluting the user's real profile. The default root is resolved
	// through the `Utilities::FiddeeRoot` atom so the dotfile name lives
	// in one place.
	if let Ok(UserOverride) = std::env::var("Lodge") {
		let OverridePath = ExpandUserPath(&UserOverride);

		dev_log!("extensions", "[Extensions] [ScanPaths] + {} (Lodge)", OverridePath.display());

		ScanPathsGuard.push(OverridePath);
	} else {
		let UserExtensionPath = crate::IPC::WindServiceHandlers::Utilities::FiddeeRoot::Fn().join("extensions");

		dev_log!(
			"extensions",
			"[Extensions] [ScanPaths] + {} (User)",
			UserExtensionPath.display()
		);

		ScanPathsGuard.push(UserExtensionPath);
	}

	// Atom U1: additional paths via `Extend`. Mirrors
	// VS Code's `--extensions-dir=<a>:<b>:<c>` CLI. Platform-separator:
	// semicolon on Windows (matches PATHEXT), colon elsewhere.
	if let Ok(Extras) = std::env::var("Extend") {
		let Separator = if cfg!(target_os = "windows") { ';' } else { ':' };

		for Candidate in Extras.split(Separator) {
			let Trimmed = Candidate.trim();

			if Trimmed.is_empty() {
				continue;
			}

			let ExtraPath = ExpandUserPath(Trimmed);

			dev_log!("extensions", "[Extensions] [ScanPaths] + {} (Extend)", ExtraPath.display());

			ScanPathsGuard.push(ExtraPath);
		}
	}

	// Atom U1: development extensions path - the VS Code equivalent of
	// `--extensionDevelopmentPath=<dir>`. Extensions here always load
	// regardless of enablement state; kept separate from user-scope so a
	// broken dev extension doesn't persist into the user's profile.
	if let Ok(DevExtensions) = std::env::var("Probe") {
		let DevPath = ExpandUserPath(&DevExtensions);

		dev_log!("extensions", "[Extensions] [ScanPaths] + {} (Probe)", DevPath.display());

		ScanPathsGuard.push(DevPath);
	}

	let ScanPaths = ScanPathsGuard.clone();

	dev_log!("extensions", "[Extensions] [ScanPaths] Configured: {:?}", ScanPaths);

	Ok(ScanPaths)
}

/// Expand a leading `~/` to `$HOME/` for user-provided paths. Env-var
/// overrides frequently come from operators typing `~/.vscode/extensions`
/// without shell expansion (e.g. in `.env` files, GUI launchers, sidecar
/// manifests). Leaves absolute and relative paths untouched.
fn ExpandUserPath(Raw:&str) -> PathBuf {
	if let Some(Stripped) = Raw.strip_prefix("~/") {
		if let Some(Home) = dirs::home_dir() {
			return Home.join(Stripped);
		}
	}

	PathBuf::from(Raw)
}