feat: 拆分 mirror-core

- 拆分 mirror-core，优化项目结构
feat: 目录结构迁移优化
2026-10-09 19:33:23 +08:00 · 2026-09-12 10:45:39 +08:00
43 changed files with 2102 additions and 1212 deletions
@@ -151,6 +151,15 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"

+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.16"
@@ -166,36 +175,159 @@ version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"

+[[package]]
+name = "crossterm"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
+dependencies = [
+ "bitflags",
+ "crossterm_winapi",
+ "derive_more",
+ "document-features",
+ "mio",
+ "parking_lot",
+ "rustix",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "deranged"
 version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"

+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "document-features"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
+dependencies = [
+ "litrs",
+]
+
 [[package]]
 name = "dunce"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"

+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
 [[package]]
 name = "either"
 version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"

+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"

+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "inquire"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6654738b8024300cf062d04a1c13c10c8e2cea598ec1c47dc9b6641159429756"
+dependencies = [
+ "bitflags",
+ "crossterm",
+ "dyn-clone",
+ "fuzzy-matcher",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "inventory"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@@ -214,6 +346,18 @@ version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"

+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litrs"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+
 [[package]]
 name = "lock_api"
 version = "0.4.14"
@@ -263,14 +407,28 @@ version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"

+[[package]]
+name = "mio"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys",
+]
+
 [[package]]
 name = "mirror-cli"
 version = "0.1.0"
 dependencies = [
 "anyhow",
 "clap",
+ "inquire",
 "mirror-core",
 "mlua",
+ "tempfile",
 "tracing",
 ]

@@ -278,7 +436,6 @@ dependencies = [
 name = "mirror-core"
 version = "0.1.0"
 dependencies = [
- "anyhow",
 "dunce",
 "mlua",
 "serde",
@@ -311,8 +468,10 @@ checksum = "d96e5d00f19d8c46c71ceaced99593b90c31c57aa1fe2cb3e93a8b1698eedba9"
 dependencies = [
 "bstr",
 "either",
+ "inventory",
 "libc",
 "mlua-sys",
+ "mlua_derive",
 "num-traits",
 "parking_lot",
 "rustc-hash",
@@ -332,6 +491,17 @@ dependencies = [
 "pkg-config",
 ]

+[[package]]
+name = "mlua_derive"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87de1e4bdfaa4bb99d8c1449d8a34b0f19e649ef68eb5d4e8dbf1e9ec6f4a084"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
@@ -427,6 +597,12 @@ dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -459,12 +635,46 @@ version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"

+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -510,6 +720,37 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"

+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-mio"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
+dependencies = [
+ "libc",
+ "mio",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.15.2"
@@ -550,6 +791,19 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.20"
@@ -695,6 +949,18 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -707,6 +973,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"

+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
 [[package]]
 name = "which"
 version = "8.0.6"
@@ -716,6 +988,28 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -18,7 +18,7 @@ description = "A fast, safe Rust shim launcher for Scoop"
 [workspace.dependencies]
 anyhow = "1.0.104"

-mlua = { version = "0.12.0", features = ["lua54", "vendored","send"] }
+mlua = { version = "0.12.0", features = ["lua54", "vendored","send","macros"] }
 windows-sys = { version = "0.61.2", features = [
    "Win32_Foundation",
    "Win32_System_Com",
@@ -11,6 +11,8 @@ path = "src/main.rs"
 [dependencies]
 mirror-core = { path = "../mirror-core" }
 clap = { version = "4.6.6", features = ["cargo", "color", "derive","string"] }
+inquire="0.9.4"
+tempfile="3.27.0"# 用于安全原子写入
 mlua = { workspace = true }
 anyhow = { workspace = true }
 tracing = { workspace = true }
@@ -2,16 +2,20 @@ use crate::commands::dynamic::MrCommand;
 use clap::{Arg, ArgAction, Command};
 use mirror_core::LogLevel;
 use std::ffi::OsString;
+// 核心保留字：系统底座命令，神圣不可侵犯
+const RESERVED_COMMANDS: &[&str] = &["use", "log", "help"];
 // 引入强类型枚举
 pub fn build(dynamic_cmds: MrCommand) -> Command {
    let mut app = Command::new("mr")
        .about(env!("CARGO_PKG_DESCRIPTION"))
        .version(env!("CARGO_PKG_VERSION"))
        .arg_required_else_help(true)
-        .subcommand(log_subcommand());
+        .subcommand(log_subcommand())
+        .subcommand(use_subcommand());

    for (name, sub_cmd) in dynamic_cmds.commands {
-        if name == "log" {
+        if RESERVED_COMMANDS.contains(&name.as_str()) {
+            // 用户要是手痒写了 use.lua 或 log.lua，直接装作没看见
            continue;
        }
        // let a =name.as_str()
@@ -24,6 +28,24 @@ pub fn build(dynamic_cmds: MrCommand) -> Command {
    }
    app
 }
+/// 核心内置命令：版本切换
+fn use_subcommand() -> Command {
+    Command::new("use")
+        .about("切换指定工具的生效版本 (支持交互式选择)")
+        .arg(
+            Arg::new("tool")
+                .required(true)
+                .value_name("TOOL")
+                .help("目标工具名称（在 mirror.lua 中声明的 key，例如 node）"),
+        )
+        .arg(
+            Arg::new("version")
+                .required(false)
+                .value_name("VERSION")
+                .help("目标版本号（省略时进入交互式单选）"),
+        )
+}
+
 /// 构建基础 CLI 骨架（内置 Rust 原生命令与参数规则）
 fn log_subcommand() -> Command {
    Command::new("log")
@@ -3,7 +3,7 @@ use mirror_core::{conversion_err, validation_error};
 use mlua::{FromLua, Lua, Value};
 use std::collections::HashMap;

-const ALLOWED_KEYS: &[&str] = &["handler", "description"];
+const ALLOWED_KEYS: &[&str] = &["module", "description"];

 #[derive(Debug, Default, Clone)]
 pub struct MrCommand {
@@ -1,2 +1,5 @@
 pub(crate) mod builtin;
 pub(crate) mod dynamic;
+mod use_cmd;
+
+pub use use_cmd::switch_version;
@@ -0,0 +1,145 @@
+use inquire::Select;
+use std::fs::{self, File};
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use tempfile::NamedTempFile;
+
+// 引入你的 mirror-core 类型
+use mirror_core::{MirrorRegistry, TargetConfig};
+
+#[derive(Debug)]
+pub enum UseError {
+    ToolNotFound(String),
+    NotVersioned(String),
+    HomeDirNotFound(PathBuf),
+    NoVersionsAvailable(PathBuf),
+    UserCancelled,
+    Io(io::Error),
+    TargetValidationFailed(PathBuf),
+}
+
+/// 执行版本切换主流程
+pub fn switch_version(
+    registry: &MirrorRegistry,
+    tool_name: &str,
+    target_version: Option<&str>,
+) -> Result<(), UseError> {
+    // 1. 获取配置并断言必须是多版本工具
+    let spec = registry
+        .targets
+        .get(tool_name)
+        .ok_or_else(|| UseError::ToolNotFound(tool_name.to_string()))?;
+
+    let (home, version_file) = match &spec.target {
+        TargetConfig::Versioned {
+            home, version_file, ..
+        } => {
+            let v_file = version_file.as_deref().unwrap_or(".version");
+            (home, v_file)
+        }
+        TargetConfig::Static(_) => {
+            return Err(UseError::NotVersioned(tool_name.to_string()));
+        }
+    };
+
+    if !home.exists() {
+        return Err(UseError::HomeDirNotFound(home.clone()));
+    }
+
+    // 2. 扫描候选版本目录
+    let available_versions = scan_versions(home)?;
+    if available_versions.is_empty() {
+        return Err(UseError::NoVersionsAvailable(home.clone()));
+    }
+
+    // 3. 确定目标版本（命令行传入 OR 唤起 Inquire 单选菜单）
+    let selected_ver = match target_version {
+        Some(ver) => {
+            // 如果用户传了参，校验是否在候选集中（防呆）
+            if !available_versions.iter().any(|v| v == ver) {
+                eprintln!(
+                    "警告: 目录 {:?} 下未发现版本 '{}'，仍将强制写入。",
+                    home, ver
+                );
+            }
+            ver.to_string()
+        }
+        None => {
+            // 尝试读取当前已激活的版本，作为 Inquire 的默认初始高亮项
+            let current_version_path = home.join(version_file);
+            let current_ver = fs::read_to_string(&current_version_path)
+                .map(|s| s.trim().to_string())
+                .ok();
+
+            prompt_user_select(&available_versions, current_ver.as_deref())?
+        }
+    };
+
+    // 4. 原子化持久化写入版本文件
+    let dest_version_path = home.join(version_file);
+    atomic_write(&dest_version_path, &selected_ver).map_err(UseError::Io)?;
+
+    println!("✔ 已成功将 '{}' 切换至版本: {}", tool_name, selected_ver);
+    Ok(())
+}
+
+/// 扫描 home 目录下的非隐藏有效子文件夹作为版本列表
+fn scan_versions(home: &Path) -> Result<Vec<String>, UseError> {
+    let mut versions = Vec::new();
+
+    let entries = fs::read_dir(home).map_err(UseError::Io)?;
+    for entry in entries.filter_map(|e| e.ok()) {
+        let path = entry.path();
+        if path.is_dir() {
+            if let Some(dir_name) = path.file_name().and_then(|n| n.to_str()) {
+                // 排除以点开头的隐藏目录（如 .git, .cache）
+                if !dir_name.starts_with('.') {
+                    versions.push(dir_name.to_string());
+                }
+            }
+        }
+    }
+
+    // 自然排序版本列表
+    versions.sort();
+    Ok(versions)
+}
+
+/// 唤起 Inquire 进行交互单选
+fn prompt_user_select(
+    versions: &[String],
+    default_version: Option<&str>,
+) -> Result<String, UseError> {
+    let mut prompt = Select::new("请选择要激活的目标版本:", versions.to_vec());
+
+    // 如果能读取到当前版本，默认选中该项
+    if let Some(def) = default_version {
+        if let Some(idx) = versions.iter().position(|v| v == def) {
+            prompt.starting_cursor = idx;
+        }
+    }
+
+    prompt.prompt().map_err(|_| UseError::UserCancelled)
+}
+
+/// 使用临时文件同目录重命名实现“原子写入”
+///
+/// 杜绝中途掉电、杀死进程导致的空文件损坏
+fn atomic_write(dest_path: &Path, content: &str) -> io::Result<()> {
+    let parent_dir = dest_path
+        .parent()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Parent dir not found"))?;
+
+    // 必须在目标文件的同级目录下创建临时文件，跨盘符/分区会导致原子重命名 (Rename) 失败
+    let mut temp_file = NamedTempFile::new_in(parent_dir)?;
+
+    // 写入纯净内容，并强制落盘刷新 (Flush)
+    temp_file.write_all(content.trim().as_bytes())?;
+    temp_file.write_all(b"\n")?; // 末尾留标准换行符
+    temp_file.as_file().sync_all()?;
+
+    // 核心操作：原子覆盖（在 Windows 上内部会调用 ReplaceFileW，在 Unix 则是 rename）
+    temp_file.persist(dest_path).map_err(|e| e.error)?;
+
+    Ok(())
+}
@@ -2,8 +2,10 @@ use crate::cli;
 use crate::commands::{builtin, dynamic::MrCommand};
 use crate::error::ExecuteError;
 use crate::plugins::register_mr_command;
+use crate::commands::switch_version;
 use anyhow::{Context, Result};
 use mirror_core::{Layout, LuaRuntime, register_basics};
+use mirror_core::MirrorRegistry;
 // 成功的标准退出码
 pub const EXIT_SUCCESS: i32 = 0;

@@ -14,7 +16,7 @@ pub const EXIT_COMMAND_NOT_FOUND: i32 = 12; // 找不到指定的子命令
 pub const EXIT_BUILTIN_ERROR: i32 = 13; // 原生命令（如 log）执行失败

 pub fn run(layout: &Layout) -> Result<(), ExecuteError> {
-    let registry_file = layout.base_dir.join("commands").join("commands.lua");
+

    let runtime = LuaRuntime::builder()
        .with(|lua| register_basics(lua, layout))
@@ -22,6 +24,7 @@ pub fn run(layout: &Layout) -> Result<(), ExecuteError> {
        .build()
        .map_err(|e| ExecuteError::new(EXIT_RUNTIME_ERROR, e))?;

+    let registry_file = layout.base_dir.join("commands").join("commands.lua");
    let commands: MrCommand = runtime
        .eval_script(&registry_file)
        .with_context(|| format!("加载命令配置失败: {}", registry_file.display()))
@@ -31,6 +34,24 @@ pub fn run(layout: &Layout) -> Result<(), ExecuteError> {
    let matches = app.get_matches();

    match matches.subcommand() {
+
+        Some(("use", sub_matches)) => {
+            let tool = sub_matches.get_one::<String>("tool").unwrap();
+            let version = sub_matches.get_one::<String>("version").map(|s| s.as_str());
+
+            // 惰性加载 mirror.lua：按需获取 MirrorRegistry
+            let mirror_file = layout.base_dir.join("mirror.lua");
+            let registry: MirrorRegistry = runtime
+                .eval_script(&mirror_file)
+                .with_context(|| format!("解析主配置失败: {}", mirror_file.display()))
+                .map_err(|e| ExecuteError::new(EXIT_CONFIG_ERROR, e))?;
+
+            if let Err(e) = switch_version(&registry, tool, version) {
+                eprintln!("[mr] 切换失败: {:?}", e);
+                std::process::exit(1);
+            }
+        }
+
        // 分支 A: 原生 Rust 实现的命令
        Some(("log", sub_m)) => {
            builtin::log_handle(&layout, sub_m)
@@ -58,7 +79,7 @@ pub fn run(layout: &Layout) -> Result<(), ExecuteError> {
        }

        // 分支 C: 未输入子命令（通常已被 Clap 的 arg_required_else_help 拦截）
-        None => {}
+        None => {}//unreachable!(),
    }
    Ok(())
 }
@@ -1,4 +1,4 @@
-use mirror_core::{Error, Result};
+use mirror_core::Result;
 use mlua::{Lua, Table, Value};

 /// 仅存在于 CLI 侧的 DSL 扩展函数
@@ -4,7 +4,6 @@ version = { workspace = true }
 edition = { workspace = true }

 [dependencies]
-anyhow = { workspace = true }
 mlua = { workspace = true }
 dunce = { workspace = true }
 tinyjson = { workspace = true }
@@ -15,3 +14,9 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing-appender = { workspace = true }
 thiserror = "2.0.20"
+
+
+
+[features]
+default = []
+args = []
@@ -0,0 +1,39 @@
+use std::collections::HashMap;
+use std::ffi::OsString;
+
+/// 单个目标程序的代理规格配置
+
+
+    /// 1. 核心参数路由解析（Delegation 到 Spec 的路由逻辑）
+    pub fn expand_aliases<I, S>(aliases: &HashMap<String, Vec<OsString>>, args: I) -> Vec<OsString>
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<std::ffi::OsStr>,
+    {
+        let arg_iter = args.into_iter();
+
+        // 1. 预分配容量：利用迭代器的下限提示，避免多次 Realloc
+        let (lower_bound, _) = arg_iter.size_hint();
+        let mut expanded_args: Vec<OsString> = Vec::with_capacity(lower_bound);
+
+        for i in arg_iter {
+            let os_str = i.as_ref();
+
+            let arg_str = os_str.to_string_lossy();
+
+            // 检查参数是否带有 mr: 前缀
+            if let Some(alias_key) = arg_str.strip_prefix("mr:") {
+                // 如果在加载期打平好的字典中找到了对应的别名，直接展开追加
+                if let Some(alias_values) = aliases.get(alias_key) {
+                    expanded_args.extend(alias_values.iter().cloned());
+                } else {
+                    // 如果找不到对应的别名，按原样参数追加
+                    expanded_args.push(os_str.to_os_string());
+                }
+            } else {
+                // 普通参数，直接追加
+                expanded_args.push(os_str.to_os_string());
+            }
+        }
+        expanded_args
+    }
@@ -0,0 +1,2 @@
+pub(crate) mod alias;
+pub(crate) mod tokens;
@@ -1,68 +1,5 @@
-use mlua::LuaString;
 use std::ffi::OsString;

-/// 将 Lua 字符串转为 Rust 字符串；非 UTF-8 按系统默认的 ANSI/OEM (如 GBK) 进行安全解码
-pub fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {
-    let raw_bytes = &s.as_bytes();
-    // 1. Unix 平台：直接零拷贝透传原始字节（无损支持任意编码）
-    #[cfg(unix)]
-    {
-        use std::os::unix::ffi::OsStrExt;
-        Ok(OsStr::from_bytes(raw_bytes).to_os_string())
-    }
-    // 2. Windows 平台：优先按 UTF-8 解码，失败则按当前系统本地代码页 (ANSI/GBK) 转换
-    #[cfg(windows)]
-    {
-        // 先尝试标准的 UTF-8
-        if let Ok(utf8_str) = std::str::from_utf8(raw_bytes) {
-            return Ok(OsString::from(utf8_str));
-        }
-
-        unsafe {
-            use std::os::windows::ffi::OsStringExt;
-            use windows_sys::Win32::Globalization::{
-                CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
-            };
-
-            if raw_bytes.is_empty() {
-                return Ok(OsString::new());
-            }
-
-            let len = MultiByteToWideChar(
-                CP_ACP,
-                MB_ERR_INVALID_CHARS,
-                raw_bytes.as_ptr(),
-                raw_bytes.len() as i32,
-                std::ptr::null_mut(),
-                0,
-            );
-
-            if len <= 0 {
-                // 构造一个带上下文的 FromLua 转换错误，便于定位配置问题
-                return Err(mlua::Error::FromLuaConversionError {
-                    from: "LuaString",
-                    to: "OsString".to_string(),
-                    message: Some(
-                        format!("字符串{:?}包含无效或当前系统无法识别的编码字节", s).to_string(),
-                    ),
-                });
-            }
-
-            let mut buf = vec![0u16; len as usize];
-            MultiByteToWideChar(
-                CP_ACP,
-                MB_ERR_INVALID_CHARS,
-                raw_bytes.as_ptr(),
-                raw_bytes.len() as i32,
-                buf.as_mut_ptr(),
-                len,
-            );
-
-            Ok(OsString::from_wide(&buf))
-        }
-    }
-}
-
 /// 将输入的字符串按 Shell 规则切分为独立的 CLI 参数 Token
 /// - 自动过滤连续空格
 /// - 支持单引号 `'...'` 和双引号 `"..."` 包裹包含空格的参数
@@ -128,7 +65,6 @@ pub fn parse_tokens(input: &str) -> Vec<OsString> {

    tokens
 }
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1,15 +1,10 @@
+use crate::{Error, Result};
 use mlua::LuaString;
-use std::ffi::OsString;
-use std::path::Path;
+use std::ffi::{OsStr, OsString};
+use std::fmt;

-/// 将 Path 转换为适合 Lua 使用的安全字符串路径
-pub fn normalize_path_for_lua(path: &Path) -> String {
-    // 自动将 Windows UNC 规范路径转回传统路径
-    let simplified = dunce::simplified(path);
-    simplified.to_string_lossy().replace('\\', "/")
-}
-
-pub fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {
+/// Lua 字符串 -> OsString（Linux 直接透传字节，Windows 回退到系统代码页）
+pub(crate) fn lua_string_2_os_string(s: &LuaString) -> Result<OsString> {
    let raw_bytes = &s.as_bytes();
    // 1. Unix 平台：直接零拷贝透传原始字节（无损支持任意编码）
    #[cfg(unix)]
@@ -46,12 +41,10 @@ pub fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {

            if len <= 0 {
                // 构造一个带上下文的 FromLua 转换错误，便于定位配置问题
-                return Err(mlua::Error::FromLuaConversionError {
+                return Err(Error::EncodingError {
                    from: "LuaString",
                    to: "OsString".to_string(),
-                    message: Some(
-                        format!("字符串{:?}包含无效或当前系统无法识别的编码字节", s).to_string(),
-                    ),
+                    message: format!("字符串{:?}包含无效或当前系统无法识别的编码字节", s),
                });
            }

@@ -69,3 +62,28 @@ pub fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {
        }
    }
 }
+
+/// 跨平台检查 `OsStr` 中是否含 NUL 字符
+pub(crate) fn ensure_no_nul(context: &impl fmt::Display, os_str: &OsStr) -> Result<()> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::ffi::OsStrExt;
+        if os_str.as_bytes().contains(&0) {
+            return Err(Error::ContainsNul(format!(
+                "{} 的值不能包含 NUL 字符",
+                context
+            )));
+        }
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStrExt;
+        if os_str.encode_wide().any(|c| c == 0) {
+            return Err(Error::ContainsNul(format!(
+                "{} 的值不能包含 NUL 字符",
+                context
+            )));
+        }
+    }
+    Ok(())
+}
@@ -0,0 +1,132 @@
+//! Lua 边界层：只负责把 Lua 值搬成 DTO，不做任何语义判断。
+//!
+//! 这一层实现的是 mlua 的 `FromLua`，错误天然是 `mlua::Error`。
+//! 领域规则（必填字段、类型、编码、命令名、别名环）全部在 `model.rs` 的
+//! `TryFrom` 里，那里的错误统一是 `crate::Error`。
+
+use super::model::{MirrorSpec, TargetSpec};
+use mlua::{FromLua, Lua, Table, Value};
+
+/// 注册表 DTO：键值对原样保留，命令名合法性交给领域层判断。
+pub(crate) struct MirrorSpecDto {
+    pub entries: Vec<(Value, TargetSpecDto)>,
+}
+
+impl FromLua for MirrorSpecDto {
+    fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
+        let root = value
+            .as_table()
+            .ok_or_else(|| mlua::Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "Table".into(),
+                message: Some("mirror 全局注册表顶层必须是 table".into()),
+            })?;
+
+        let mut entries = Vec::new();
+        for pair in root.pairs::<Value, Value>() {
+            let (key, entry) = pair?;
+            let entry = entry
+                .as_table()
+                .ok_or_else(|| mlua::Error::FromLuaConversionError {
+                    from: entry.type_name(),
+                    to: "Table".into(),
+                    message: Some(format!(
+                        "目标工具 '{}' 的配置必须是 table，实际是 {}",
+                        display_key(&key),
+                        entry.type_name()
+                    )),
+                })?;
+            entries.push((key, TargetSpecDto::from_table(&entry)?));
+        }
+        Ok(Self { entries })
+    }
+}
+
+/// 单个目标工具配置的 DTO：字段原样保留，类型判断留给领域层。
+///
+/// 字段一律用 `Value`：Lua 里"字段不存在"和"字段是 nil"是同一件事，
+/// 都用 `Value::Nil` 表示。用 `Option<Value>` 反而会有两种"缺失"写法。
+pub(crate) struct TargetSpecDto {
+    pub target: TargetDto,
+    pub args: Value,
+    pub env: Value,
+    pub aliases: Value,
+}
+
+impl TargetSpecDto {
+    fn from_table(table: &Table) -> mlua::Result<Self> {
+        Ok(Self {
+            target: TargetDto::from_value(table.get::<Value>("target")?)?,
+            args: table.get::<Value>("args")?,
+            env: table.get::<Value>("env")?,
+            aliases: table.get::<Value>("aliases")?,
+        })
+    }
+}
+
+/// target 的"形状"：标量还是多版本 table。
+///
+/// `Value::Nil`（字段没写）会落进 `Scalar`，由领域层决定它是错误还是默认值。
+/// 字符串能不能当路径、table 里 `home` 是否必填，也都留给领域层判断。
+pub(crate) enum TargetDto {
+    Scalar(Value),
+    Versioned {
+        home: Value,
+        version_file: Value,
+        current: Value,
+    },
+}
+
+impl TargetDto {
+    fn from_value(value: Value) -> mlua::Result<Self> {
+        match value {
+            Value::Table(table) => Ok(Self::Versioned {
+                home: table.get::<Value>("home")?,
+                version_file: table.get::<Value>("version_file")?,
+                current: table.get::<Value>("current")?,
+            }),
+            other => Ok(Self::Scalar(other)),
+        }
+    }
+}
+
+/// 错误信息里显示注册表 key；非字符串 key 退化成类型名。
+fn display_key(key: &Value) -> String {
+    match key {
+        Value::String(s) => s
+            .to_str()
+            .map(|s| s.to_string())
+            .unwrap_or_else(|_| "<非 UTF-8>".to_string()),
+        other => other.type_name().to_string(),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 兼容适配器
+//
+// 消费方目前仍使用 `runtime.eval_script::<MirrorRegistry>(...)` 和
+// `MirrorTarget::from_lua(...)`，所以保留这两个薄适配器：
+// 边界提取（DTO）→ 领域转换（TryFrom）→ 错误翻译（Into）。
+// 领域逻辑一行都不在这两个 impl 里。
+// ---------------------------------------------------------------------------
+
+impl FromLua for MirrorSpec {
+    fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {
+        let dto = MirrorSpecDto::from_lua(value, lua)?;
+        MirrorSpec::try_from(dto).map_err(Into::into)
+    }
+}
+
+impl FromLua for TargetSpec {
+    fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
+        let table = value
+            .as_table()
+            .ok_or_else(|| mlua::Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "Table".into(),
+                message: Some("目标工具配置必须是 table".into()),
+            })?;
+        let dto = TargetSpecDto::from_table(&table)?;
+        TargetSpec::try_from(dto).map_err(Into::into)
+    }
+}
@@ -0,0 +1,26 @@
+pub(crate) mod convert;
+pub(crate) mod dto;
+pub(crate) mod model;
+pub(crate) mod naming;
+pub(crate) mod values;
+
+pub use model::{MirrorSpec, Target, TargetSpec};
+pub use naming::parse_command_name;
+
+// 兼容旧名：mirror-shim / mirror-cli 目前仍按这些名字引用。
+// 等消费方迁移到 MirrorSpec / TargetSpec / Target 后可以删掉。
+pub type MirrorRegistry = MirrorSpec;
+pub type MirrorTarget = TargetSpec;
+pub type TargetConfig = Target;
+
+use crate::{LuaRuntime, Result};
+use std::path::Path;
+
+/// 配置加载入口：边界提取（DTO）→ 领域转换（TryFrom）。
+///
+/// 调用方拿到的错误全部是 `crate::Error`；DTO 与 mlua 的错误类型
+/// 都被关在这个函数内部。
+pub fn load_mirror_spec(runtime: &LuaRuntime, path: impl AsRef<Path>) -> Result<MirrorSpec> {
+    let dto: dto::MirrorSpecDto = runtime.eval_script(path)?;
+    MirrorSpec::try_from(dto)
+}
@@ -0,0 +1,268 @@
+//! 领域模型：只描述"配置应该长什么样"，不实现 mlua 的 `FromLua`。
+//!
+//! 两阶段加载：
+//!   1. `config::dto` 把 Lua 值搬成 DTO（边界，错误是 mlua 形状）
+//!   2. 本文件的 `TryFrom<DTO>` 做语义校验与类型转换（错误全部是 `crate::Error`）
+
+use crate::config::convert::{ensure_no_nul, lua_string_2_os_string};
+use crate::config::dto::{MirrorSpecDto, TargetDto, TargetSpecDto};
+use crate::config::values::{parse_aliases, parse_args, parse_env};
+use crate::{Error, Result, parse_command_name};
+use mlua::Value;
+use std::collections::HashMap;
+use std::ffi::{OsStr, OsString};
+use std::path::PathBuf;
+
+pub struct MirrorSpec {
+    pub targets: HashMap<String, TargetSpec>,
+}
+
+impl TryFrom<MirrorSpecDto> for MirrorSpec {
+    type Error = Error;
+
+    fn try_from(dto: MirrorSpecDto) -> Result<Self> {
+        let mut targets = HashMap::with_capacity(dto.entries.len());
+        for (key, tool) in dto.entries {
+            let name = parse_command_name(&key)?;
+            targets.insert(name, TargetSpec::try_from(tool)?);
+        }
+        Ok(Self { targets })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct TargetSpec {
+    /// 目标程序可执行文件路径
+    pub target: Target,
+    /// 默认预设参数列表
+    pub args: Vec<OsString>,
+    /// 参数别名映射表（用于展开以 mr: 为前缀的别名）
+    pub aliases: HashMap<String, Vec<OsString>>,
+    /// 注入/覆盖的环境变量
+    pub env: HashMap<String, OsString>,
+}
+
+impl TargetSpec {
+    pub fn resolve_args<I, S>(&self, args: I) -> Vec<OsString>
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<OsStr>,
+    {
+        crate::args::alias::expand_aliases(&self.aliases, args)
+    }
+}
+
+impl TryFrom<TargetSpecDto> for TargetSpec {
+    type Error = Error;
+
+    fn try_from(dto: TargetSpecDto) -> Result<Self> {
+        let target = Target::try_from(dto.target)?;
+
+        let args = match dto.args {
+            Value::Nil => Vec::new(),
+            value => parse_args(&value)?,
+        };
+        let aliases = match dto.aliases {
+            Value::Nil => HashMap::new(),
+            value => parse_aliases(&value)?,
+        };
+        let env = match dto.env {
+            Value::Nil => HashMap::new(),
+            value => parse_env(&value)?,
+        };
+
+        Ok(Self {
+            target,
+            args,
+            aliases,
+            env,
+        })
+    }
+}
+
+/// 目标可执行文件的定位配置（支持静态路径与多版本 Table）
+#[derive(Debug, Clone)]
+pub enum Target {
+    /// 静态单版本工具
+    Static(PathBuf),
+    /// 多版本管理
+    Versioned {
+        /// 工具主根目录（供 mr use 扫描候选版本）
+        home: PathBuf,
+        /// 版本真相源文件名（如 ".version"，可选，默认 ".version"）
+        version_file: Option<String>,
+        /// 当前激活版本的可执行文件完整路径（若未激活或不存在则为 None）
+        current: Option<PathBuf>,
+    },
+}
+
+impl Default for Target {
+    fn default() -> Self {
+        Target::Static(PathBuf::default())
+    }
+}
+
+impl Target {
+    /// 垫片程序（mirror-shim）专用快速通道：提取最终可执行路径
+    ///
+    /// - Static: 返回自身路径
+    /// - Versioned: 返回 current 路径（若未激活则返回 None）
+    pub fn executable_path(&self) -> Option<&PathBuf> {
+        match self {
+            Target::Static(path) => Some(path),
+            Target::Versioned { current, .. } => current.as_ref(),
+        }
+    }
+
+    /// 管理程序（mr-cli）专用辅助方法：判断是否支持多版本
+    pub fn is_versioned(&self) -> bool {
+        matches!(self, Target::Versioned { .. })
+    }
+}
+
+impl TryFrom<TargetDto> for Target {
+    type Error = Error;
+
+    fn try_from(dto: TargetDto) -> Result<Self> {
+        match dto {
+            TargetDto::Scalar(Value::String(s)) => {
+                let os_str = lua_string_2_os_string(&s)?;
+                ensure_no_nul(&"target", &os_str)?;
+                Ok(Target::Static(PathBuf::from(os_str)))
+            }
+            TargetDto::Scalar(Value::Nil) => Err(Error::MissingField {
+                field: "target（应为字符串路径或多版本配置表）".into(),
+            }),
+            TargetDto::Scalar(other) => Err(Error::TypeMismatch {
+                field: "target".into(),
+                expected: "有效路径字符串或多版本配置表",
+                actual: other.type_name(),
+            }),
+            TargetDto::Versioned {
+                home,
+                version_file,
+                current,
+            } => {
+                let home = required_path(home, "home（多版本 target 表）", "target.home")?;
+                let version_file = optional_string(version_file, "target.version_file")?;
+                let current = optional_path(current, "target.current")?;
+
+                Ok(Target::Versioned {
+                    home,
+                    version_file,
+                    current,
+                })
+            }
+        }
+    }
+}
+
+/// 必填路径字段：缺失/nil 报 `MissingField`，类型不符报 `TypeMismatch`
+fn required_path(value: Value, field: &str, context: &str) -> Result<PathBuf> {
+    match value {
+        Value::Nil => Err(Error::MissingField {
+            field: field.to_string(),
+        }),
+        Value::String(s) => {
+            let os_str = lua_string_2_os_string(&s)?;
+            ensure_no_nul(&context, &os_str)?;
+            Ok(PathBuf::from(os_str))
+        }
+        other => Err(Error::TypeMismatch {
+            field: context.to_string(),
+            expected: "路径字符串",
+            actual: other.type_name(),
+        }),
+    }
+}
+
+/// 可选字符串字段：缺失/nil 视为 None
+fn optional_string(value: Value, context: &str) -> Result<Option<String>> {
+    match value {
+        Value::Nil => Ok(None),
+        Value::String(s) => {
+            let os_str = lua_string_2_os_string(&s)?;
+            ensure_no_nul(&context, &os_str)?;
+            Ok(Some(os_str.to_string_lossy().into_owned()))
+        }
+        other => Err(Error::TypeMismatch {
+            field: context.to_string(),
+            expected: "字符串 (String)",
+            actual: other.type_name(),
+        }),
+    }
+}
+
+/// 可选路径字段：缺失/nil 视为 None
+fn optional_path(value: Value, context: &str) -> Result<Option<PathBuf>> {
+    match value {
+        Value::Nil => Ok(None),
+        Value::String(s) => {
+            let os_str = lua_string_2_os_string(&s)?;
+            ensure_no_nul(&context, &os_str)?;
+            Ok(Some(PathBuf::from(os_str)))
+        }
+        other => Err(Error::TypeMismatch {
+            field: context.to_string(),
+            expected: "有效路径字符串 (LuaString) 或 nil",
+            actual: other.type_name(),
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 领域转换直接产出 crate::Error，不再被 mlua 包一层
+    #[test]
+    fn scalar_target_with_wrong_type_is_domain_error() {
+        let err = Target::try_from(TargetDto::Scalar(Value::Integer(42))).unwrap_err();
+        match err {
+            Error::TypeMismatch { field, actual, .. } => {
+                assert_eq!(field, "target");
+                assert_eq!(actual, "integer");
+            }
+            other => panic!("unexpected error: {other}"),
+        }
+    }
+
+    #[test]
+    fn versioned_target_requires_home() {
+        let dto = TargetDto::Versioned {
+            home: Value::Nil,
+            version_file: Value::Nil,
+            current: Value::Nil,
+        };
+        let err = Target::try_from(dto).unwrap_err();
+        assert!(matches!(err, Error::MissingField { field } if field.starts_with("home")));
+    }
+
+    /// 字段不存在和字段是 nil，在 Lua 里是同一件事
+    #[test]
+    fn nil_target_is_missing_field() {
+        let err = Target::try_from(TargetDto::Scalar(Value::Nil)).unwrap_err();
+        assert!(matches!(err, Error::MissingField { .. }));
+    }
+
+    #[test]
+    fn optional_field_type_is_checked() {
+        let err = optional_string(Value::Integer(1), "target.version_file").unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { field, .. } if field == "target.version_file"));
+
+        let err = optional_path(Value::Integer(1), "target.current").unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { field, .. } if field == "target.current"));
+    }
+
+    #[test]
+    fn missing_target_is_missing_field() {
+        let dto = TargetSpecDto {
+            target: TargetDto::Scalar(Value::Nil),
+            args: Value::Nil,
+            env: Value::Nil,
+            aliases: Value::Nil,
+        };
+        let err = TargetSpec::try_from(dto).unwrap_err();
+        assert!(matches!(err, Error::MissingField { .. }));
+    }
+}
@@ -0,0 +1,146 @@
+//! 名称规则：注册表键（命令名）、环境变量名、别名键。
+//!
+//! 三类名称的规则不同：
+//! - 命令名：非空、不能含空白字符、不能含 `=`、不能含 NUL
+//! - 环境变量名 / 别名：非空、不能含 `=`、不能含 NUL（允许空格）
+
+use crate::{Error, NameKind, Result};
+use mlua::Value;
+
+/// 校验注册表键（命令名）
+pub fn parse_command_name(name: &Value) -> Result<String> {
+    let name = parse_string(name, NameKind::Command)?;
+
+    if name.trim().is_empty() {
+        return Err(invalid(NameKind::Command, "不能为空字符串"));
+    }
+    if name.contains(|c: char| c.is_whitespace()) {
+        return Err(invalid(
+            NameKind::Command,
+            format!("[{name}] 不能包含空格或空白字符"),
+        ));
+    }
+    if name.contains('=') {
+        return Err(invalid(NameKind::Command, format!("[{name}] 不能包含 '='")));
+    }
+    if name.contains('\0') {
+        return Err(invalid(
+            NameKind::Command,
+            format!("[{name}] 不能包含 NUL 字符"),
+        ));
+    }
+    Ok(name)
+}
+
+/// 校验环境变量名 / 别名键
+pub(crate) fn parse_name(kind: NameKind, name: &Value) -> Result<String> {
+    let name = parse_string(name, kind)?;
+
+    if name.is_empty() {
+        return Err(invalid(kind, "不能为空"));
+    }
+    if name.contains('=') {
+        return Err(invalid(kind, format!("[{name}] 不能包含 '='")));
+    }
+    if name.contains('\0') {
+        return Err(invalid(kind, format!("[{name}] 不能包含 NUL 字符")));
+    }
+    Ok(name)
+}
+
+/// 取字符串值；类型不对报 `TypeMismatch`，字节不是 UTF-8 报 `EncodingError`
+fn parse_string(value: &Value, kind: NameKind) -> Result<String> {
+    match value {
+        Value::String(s) => {
+            s.to_str()
+                .map(|text| text.to_string())
+                .map_err(|e| Error::EncodingError {
+                    from: "LuaString",
+                    to: "String".to_string(),
+                    message: format!("{kind}不是合法的 UTF-8 字符串: {e}"),
+                })
+        }
+        other => Err(Error::TypeMismatch {
+            field: kind.to_string(),
+            expected: "字符串 (String)",
+            actual: other.type_name(),
+        }),
+    }
+}
+
+fn invalid(kind: NameKind, reason: impl Into<String>) -> Error {
+    Error::InvalidName {
+        kind,
+        reason: reason.into(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mlua::Lua;
+
+    fn string(lua: &Lua, text: &str) -> Value {
+        Value::String(lua.create_string(text).unwrap())
+    }
+
+    #[test]
+    fn command_name_accepts_plain_name() {
+        let lua = Lua::new();
+        assert_eq!(parse_command_name(&string(&lua, "git")).unwrap(), "git");
+    }
+
+    #[test]
+    fn command_name_rejects_whitespace_and_equals() {
+        let lua = Lua::new();
+        for bad in ["git status", "git=1", "  ", ""] {
+            let err = parse_command_name(&string(&lua, bad)).unwrap_err();
+            assert!(
+                matches!(
+                    err,
+                    Error::InvalidName {
+                        kind: NameKind::Command,
+                        ..
+                    }
+                ),
+                "unexpected error for {bad:?}: {err}"
+            );
+        }
+    }
+
+    #[test]
+    fn command_name_type_error_is_type_mismatch() {
+        let err = parse_command_name(&Value::Integer(1)).unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { .. }));
+    }
+
+    #[test]
+    fn env_name_allows_space_but_rejects_equals() {
+        let lua = Lua::new();
+        assert_eq!(
+            parse_name(NameKind::EnvVar, &string(&lua, "MY VAR")).unwrap(),
+            "MY VAR"
+        );
+        let err = parse_name(NameKind::EnvVar, &string(&lua, "FOO=1")).unwrap_err();
+        assert!(matches!(
+            err,
+            Error::InvalidName {
+                kind: NameKind::EnvVar,
+                ..
+            }
+        ));
+    }
+
+    #[test]
+    fn alias_name_rejects_empty() {
+        let lua = Lua::new();
+        let err = parse_name(NameKind::Alias, &string(&lua, "")).unwrap_err();
+        assert!(matches!(
+            err,
+            Error::InvalidName {
+                kind: NameKind::Alias,
+                ..
+            }
+        ));
+    }
+}
@@ -0,0 +1,172 @@
+use super::as_table;
+use super::scalar::{ScalarMode, to_os_strings};
+use super::sequence::as_strict_sequence;
+use crate::config::naming::parse_name;
+use crate::{Error, NameKind, Result};
+use mlua::Value;
+use std::collections::HashMap;
+use std::ffi::OsString;
+
+const CONTEXT: &str = "命令行别名 (aliases)";
+/// 数组嵌套上限，防止畸形配置打爆调用栈
+const MAX_DEPTH: usize = 16;
+/// `mr:` 引用链的最大深度
+const MAX_ALIAS_DEPTH: usize = 32;
+
+/// `aliases = { name = value }` → 已展开的别名表。
+///
+/// value 是"命令行片段"：字符串按 shell 规则分词，数组逐项处理。
+/// `mr:other` 在加载期递归展开；引用不存在的别名时原样保留；循环引用报错。
+pub(crate) fn parse_aliases(value: &Value) -> Result<HashMap<String, Vec<OsString>>> {
+    let table = as_table(value, CONTEXT)?;
+    let mut raw: HashMap<String, Vec<OsString>> = HashMap::with_capacity(table.raw_len().min(128));
+
+    for pair in table.pairs::<Value, Value>() {
+        let (raw_key, raw_value) = pair?;
+        let name = parse_name(NameKind::Alias, &raw_key)?;
+        let context = format!("别名 '{name}'");
+
+        let mut parts = Vec::new();
+        flatten(&raw_value, &context, 0, &mut parts)?;
+        raw.insert(name, parts);
+    }
+
+    expand_graph(&raw)
+}
+
+/// 递归展平标量与嵌套数组，字符串按 shell 规则分词
+fn flatten(value: &Value, context: &str, depth: usize, out: &mut Vec<OsString>) -> Result<()> {
+    if depth > MAX_DEPTH {
+        return Err(Error::ParseError(format!(
+            "{context} 的数组嵌套层级过深（超过 {MAX_DEPTH} 层）"
+        )));
+    }
+    match value {
+        Value::Table(table) => {
+            for item in as_strict_sequence(table, context)? {
+                flatten(&item, context, depth + 1, out)?;
+            }
+        }
+        scalar => out.extend(to_os_strings(scalar, ScalarMode::Tokens, context)?),
+    }
+    Ok(())
+}
+
+/// 一次 DFS 完成"环检测 + 递归展开 + 结果缓存"
+fn expand_graph(raw: &HashMap<String, Vec<OsString>>) -> Result<HashMap<String, Vec<OsString>>> {
+    let mut cache: HashMap<String, Vec<OsString>> = HashMap::with_capacity(raw.len());
+    let mut stack: Vec<String> = Vec::new();
+
+    for key in raw.keys() {
+        resolve(key, raw, &mut cache, &mut stack)?;
+    }
+    Ok(cache)
+}
+
+fn resolve(
+    key: &str,
+    raw: &HashMap<String, Vec<OsString>>,
+    cache: &mut HashMap<String, Vec<OsString>>,
+    stack: &mut Vec<String>,
+) -> Result<Vec<OsString>> {
+    if let Some(done) = cache.get(key) {
+        return Ok(done.clone());
+    }
+    if stack.iter().any(|pending| pending == key) {
+        return Err(Error::AliasCycle {
+            name: key.to_string(),
+        });
+    }
+    if stack.len() >= MAX_ALIAS_DEPTH {
+        return Err(Error::AliasTooDeep {
+            max: MAX_ALIAS_DEPTH,
+        });
+    }
+
+    stack.push(key.to_string());
+
+    let mut expanded = Vec::new();
+    if let Some(args) = raw.get(key) {
+        for arg in args {
+            let text = arg.to_string_lossy();
+            let referenced = text
+                .strip_prefix("mr:")
+                .filter(|name| raw.contains_key(*name))
+                .map(str::to_string);
+
+            match referenced {
+                Some(name) => expanded.extend(resolve(&name, raw, cache, stack)?),
+                None => expanded.push(arg.clone()),
+            }
+        }
+    }
+
+    stack.pop();
+    cache.insert(key.to_string(), expanded.clone());
+    Ok(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mlua::Lua;
+
+    fn with_aliases(code: &str) -> Result<HashMap<String, Vec<OsString>>> {
+        let lua = Lua::new();
+        let value: Value = lua.load(code).eval().unwrap();
+        parse_aliases(&value)
+    }
+
+    #[test]
+    fn tokenizes_values_and_expands_references() {
+        let aliases = with_aliases(
+            r#"return { base = "log --graph", all = { "mr:base", "--all" }, blank = "   " }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            aliases.get("base").unwrap(),
+            &vec![OsString::from("log"), OsString::from("--graph")]
+        );
+        assert_eq!(
+            aliases.get("all").unwrap(),
+            &vec![
+                OsString::from("log"),
+                OsString::from("--graph"),
+                OsString::from("--all"),
+            ]
+        );
+        assert!(aliases.get("blank").unwrap().is_empty());
+    }
+
+    #[test]
+    fn scalar_number_and_boolean_are_supported() {
+        let aliases = with_aliases(r#"return { n = 10, b = true }"#).unwrap();
+        assert_eq!(aliases.get("n").unwrap(), &vec![OsString::from("10")]);
+        assert_eq!(aliases.get("b").unwrap(), &vec![OsString::from("true")]);
+    }
+
+    #[test]
+    fn unknown_reference_is_kept_literal() {
+        let aliases = with_aliases(r#"return { a = "mr:nope" }"#).unwrap();
+        assert_eq!(aliases.get("a").unwrap(), &vec![OsString::from("mr:nope")]);
+    }
+
+    #[test]
+    fn cycle_is_reported() {
+        let err = with_aliases(r#"return { a = "mr:b", b = "mr:a" }"#).unwrap_err();
+        assert!(matches!(err, Error::AliasCycle { .. }), "unexpected: {err}");
+    }
+
+    #[test]
+    fn invalid_alias_name_is_reported() {
+        let err = with_aliases(r#"return { [""] = "x" }"#).unwrap_err();
+        assert!(matches!(
+            err,
+            Error::InvalidName {
+                kind: NameKind::Alias,
+                ..
+            }
+        ));
+    }
+}
@@ -0,0 +1,78 @@
+use super::as_table;
+use super::scalar::{ScalarMode, to_os_strings};
+use super::sequence::as_strict_sequence;
+use crate::{Error, Result};
+use mlua::Value;
+use std::ffi::OsString;
+
+const CONTEXT: &str = "命令行参数 (args)";
+
+/// `args = { … }`：一个数组元素就是一个参数（空串保留为空参数）。
+///
+/// 只支持一维基础标量：嵌套 table 会让"一个元素 = 一个参数"的语义失效。
+pub(crate) fn parse_args(value: &Value) -> Result<Vec<OsString>> {
+    let table = as_table(value, CONTEXT)?;
+    let items = as_strict_sequence(table, CONTEXT)?;
+
+    let mut args = Vec::with_capacity(items.len());
+    for (i, item) in items.iter().enumerate() {
+        if matches!(item, Value::Table(_)) {
+            return Err(Error::ParseError(format!(
+                "{CONTEXT} 仅支持一维数组，第 {} 个元素不能是 table",
+                i + 1
+            )));
+        }
+        let context = format!("{CONTEXT} 第 {} 个元素", i + 1);
+        args.extend(to_os_strings(item, ScalarMode::Verbatim, &context)?);
+    }
+    Ok(args)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mlua::Lua;
+
+    fn with_args(code: &str) -> Result<Vec<OsString>> {
+        let lua = Lua::new();
+        let value: Value = lua.load(code).eval().unwrap();
+        parse_args(&value)
+    }
+
+    #[test]
+    fn parses_scalars_and_keeps_empty_string() {
+        let args = with_args(r#"return { "--no-pager", 2, true, "" }"#).unwrap();
+        assert_eq!(
+            args,
+            vec![
+                OsString::from("--no-pager"),
+                OsString::from("2"),
+                OsString::from("true"),
+                OsString::from(""),
+            ]
+        );
+    }
+
+    #[test]
+    fn empty_array_is_empty() {
+        assert!(with_args("return {}").unwrap().is_empty());
+    }
+
+    #[test]
+    fn rejects_nested_table() {
+        let err = with_args(r#"return { { "a" } }"#).unwrap_err();
+        assert!(matches!(err, Error::ParseError(_)));
+    }
+
+    #[test]
+    fn rejects_sparse_array() {
+        let err = with_args(r#"return { "a", nil, "b" }"#).unwrap_err();
+        assert!(matches!(err, Error::ParseError(_)));
+    }
+
+    #[test]
+    fn rejects_non_table() {
+        let err = with_args(r#"return "-B""#).unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { .. }));
+    }
+}
@@ -0,0 +1,120 @@
+use super::as_table;
+use super::scalar::{ScalarMode, to_os_strings};
+use super::sequence::as_strict_sequence;
+use crate::config::naming::parse_name;
+use crate::{Error, NameKind, Result};
+use mlua::Value;
+use std::collections::HashMap;
+use std::ffi::OsString;
+
+const CONTEXT: &str = "环境变量 (env)";
+/// 数组嵌套上限，防止畸形配置打爆调用栈
+const MAX_DEPTH: usize = 16;
+
+/// `env = { KEY = value }` → 环境变量表。
+///
+/// value 可以是标量，也可以是任意深度的数组；数组会递归展平，然后按系统
+/// 路径分隔符（Windows `;`）拼接。空字符串 / 空数组 → 空值（清空该变量）。
+pub(crate) fn parse_env(value: &Value) -> Result<HashMap<String, OsString>> {
+    let table = as_table(value, CONTEXT)?;
+    let mut env = HashMap::with_capacity(table.raw_len().min(128));
+
+    for pair in table.pairs::<Value, Value>() {
+        let (raw_key, raw_value) = pair?;
+        let name = parse_name(NameKind::EnvVar, &raw_key)?;
+        let context = format!("环境变量 '{name}' 的值");
+
+        let mut parts = Vec::new();
+        flatten(&raw_value, &context, 0, &mut parts)?;
+
+        let joined = std::env::join_paths(parts)
+            .map_err(|e| Error::ParseError(format!("{context} 无法用系统路径分隔符拼接: {e}")))?;
+        env.insert(name, joined);
+    }
+
+    Ok(env)
+}
+
+/// 递归展平标量与嵌套数组（env 的字符串不做分词，整段作为一个路径段）
+fn flatten(value: &Value, context: &str, depth: usize, out: &mut Vec<OsString>) -> Result<()> {
+    if depth > MAX_DEPTH {
+        return Err(Error::ParseError(format!(
+            "{context} 的数组嵌套层级过深（超过 {MAX_DEPTH} 层）"
+        )));
+    }
+    match value {
+        Value::Table(table) => {
+            for item in as_strict_sequence(table, context)? {
+                flatten(&item, context, depth + 1, out)?;
+            }
+        }
+        scalar => out.extend(to_os_strings(scalar, ScalarMode::Verbatim, context)?),
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mlua::Lua;
+
+    fn with_env(code: &str) -> Result<HashMap<String, OsString>> {
+        let lua = Lua::new();
+        let value: Value = lua.load(code).eval().unwrap();
+        parse_env(&value)
+    }
+
+    #[test]
+    fn flattens_nested_arrays_with_path_separator() {
+        let env = with_env(r#"return { PATH = { "C:/a", { "C:/b", "C:/c" } } }"#).unwrap();
+        assert_eq!(env.get("PATH").unwrap().to_str(), Some("C:/a;C:/b;C:/c"));
+    }
+
+    #[test]
+    fn scalars_and_empty_values() {
+        let env = with_env(r#"return { A = "", B = {}, C = 3, D = true }"#).unwrap();
+        assert_eq!(env.get("A").unwrap().to_str(), Some(""));
+        assert_eq!(env.get("B").unwrap().to_str(), Some(""));
+        assert_eq!(env.get("C").unwrap().to_str(), Some("3"));
+        assert_eq!(env.get("D").unwrap().to_str(), Some("true"));
+    }
+
+    #[test]
+    fn rejects_invalid_key() {
+        let err = with_env(r#"return { ["FOO=1"] = "x" }"#).unwrap_err();
+        assert!(matches!(
+            err,
+            Error::InvalidName {
+                kind: NameKind::EnvVar,
+                ..
+            }
+        ));
+
+        let err = with_env(r#"return { [""] = "x" }"#).unwrap_err();
+        assert!(matches!(
+            err,
+            Error::InvalidName {
+                kind: NameKind::EnvVar,
+                ..
+            }
+        ));
+    }
+
+    #[test]
+    fn rejects_sparse_array_and_wrong_types() {
+        let err = with_env(r#"return { P = { "a", nil, "b" } }"#).unwrap_err();
+        assert!(matches!(err, Error::ParseError(_)));
+
+        let err = with_env(r#"return { F = function() end }"#).unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { .. }));
+
+        let err = with_env(r#"return "PATH=C:/x""#).unwrap_err();
+        assert!(matches!(err, Error::TypeMismatch { .. }));
+    }
+
+    #[test]
+    fn rejects_nul_in_value() {
+        let err = with_env(r#"return { P = { string.char(0) } }"#).unwrap_err();
+        assert!(matches!(err, Error::ContainsNul(_)));
+    }
+}
@@ -0,0 +1,27 @@
+//! Lua 值 → Rust 值的转换：`args` / `env` / `aliases`。
+//!
+//! 这一层只管"值本身"：数组形状、元素类型、键合法性、分词与拼接。
+//! 产出的错误统一是 `crate::Error` 的结构化变体；字段级语义
+//! （必填、默认值）由 `model.rs` 决定。
+
+mod aliases;
+mod args;
+mod env;
+mod scalar;
+mod sequence;
+
+pub(crate) use aliases::parse_aliases;
+pub(crate) use args::parse_args;
+pub(crate) use env::parse_env;
+
+use crate::{Error, Result};
+use mlua::{Table, Value};
+
+/// 值必须是 table，否则报 `TypeMismatch`
+pub(crate) fn as_table<'a>(value: &'a Value, context: &str) -> Result<&'a Table> {
+    value.as_table().ok_or_else(|| Error::TypeMismatch {
+        field: context.to_string(),
+        expected: "键值表 (table)",
+        actual: value.type_name(),
+    })
+}
@@ -0,0 +1,52 @@
+use crate::args::tokens::parse_tokens;
+use crate::config::convert::{ensure_no_nul, lua_string_2_os_string};
+use crate::{Error, Result};
+use mlua::Value;
+use std::ffi::OsString;
+
+/// 字符串元素的处理策略
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum ScalarMode {
+    /// 整体作为一个参数（args：一个数组元素 = 一个参数，空串保留为空参数）
+    Verbatim,
+    /// 按 shell 规则分词（aliases："status -s" → 两个参数）
+    Tokens,
+}
+
+/// 标量 → 参数列表
+///
+/// - `Nil` 产生 0 个参数（在 env 里表示"清空该变量"）
+/// - 字符串 / 整数 / 浮点 / 布尔都可以转成字符串
+/// - 其它类型报 `TypeMismatch`
+/// - 产出的每个 `OsString` 都会做 NUL 检查
+pub(super) fn to_os_strings(
+    value: &Value,
+    mode: ScalarMode,
+    context: &str,
+) -> Result<Vec<OsString>> {
+    let os_str: OsString = match value {
+        Value::String(s) => lua_string_2_os_string(s)?,
+        Value::Integer(i) => i.to_string().into(),
+        Value::Number(n) => n.to_string().into(),
+        Value::Boolean(b) => b.to_string().into(),
+        Value::Nil => return Ok(Vec::new()),
+        other => {
+            return Err(Error::TypeMismatch {
+                field: context.to_string(),
+                expected: "string / number / boolean",
+                actual: other.type_name(),
+            });
+        }
+    };
+
+    ensure_no_nul(&context, &os_str)?;
+
+    Ok(match mode {
+        ScalarMode::Verbatim => vec![os_str],
+        ScalarMode::Tokens => match os_str.to_str() {
+            Some(text) => parse_tokens(text),
+            // 非 UTF-8 字节没法按 shell 规则切分，整体作为一个参数
+            None => vec![os_str],
+        },
+    })
+}
@@ -0,0 +1,41 @@
+use crate::{Error, Result};
+use mlua::{Table, Value};
+
+/// 严格连续的纯数组校验：一次遍历 `pairs`，要求键恰好是 `1..=n` 的连续整数。
+///
+/// 返回按顺序排列的元素。空洞（`{ "a", nil, "b" }`）或字典键都会报错。
+pub(super) fn as_strict_sequence(table: &Table, context: &str) -> Result<Vec<Value>> {
+    let mut slots: Vec<Option<Value>> = Vec::with_capacity(table.raw_len().min(128));
+
+    for pair in table.pairs::<Value, Value>() {
+        let (key, value) = pair?;
+        let index = match key {
+            Value::Integer(i) if i >= 1 => (i - 1) as usize,
+            other => {
+                return Err(Error::TypeMismatch {
+                    field: context.to_string(),
+                    expected: "连续整数下标 (数组)",
+                    actual: other.type_name(),
+                });
+            }
+        };
+        if slots.len() <= index {
+            slots.resize_with(index + 1, || None);
+        }
+        slots[index] = Some(value);
+    }
+
+    let mut items = Vec::with_capacity(slots.len());
+    for (i, slot) in slots.into_iter().enumerate() {
+        match slot {
+            Some(value) => items.push(value),
+            None => {
+                return Err(Error::ParseError(format!(
+                    "{context} 第 {} 个元素为 nil 或不存在（请检查漏写引号或变量未定义）",
+                    i + 1
+                )));
+            }
+        }
+    }
+    Ok(items)
+}
@@ -1,52 +1,77 @@
 use std::fmt;
 use std::path::PathBuf;
 use thiserror::Error;
-// 构造一个带上下文的 FromLua 转换错误，便于定位配置问题
-/// 配置校验错误
-pub fn validation_error(message: impl Into<String>) -> mlua::Error {
-    mlua::Error::RuntimeError(message.into())
-}
-pub fn conversion_err(
-    from: &'static str,
-    to: impl Into<String>,
-    msg: impl Into<String>,
-) -> mlua::Error {
-    mlua::Error::FromLuaConversionError {
-        from,
-        to: to.into(),
-        message: Some(msg.into()),
-    }
-}
-/// 将底层 Lua 语法错误转换为用户友好的提示
-pub fn syntax_error(err: mlua::Error) -> mlua::Error {
-    match &err {
-        mlua::Error::SyntaxError { message, .. } => {
-            if message.contains("invalid escape sequence") || message.contains("unfinished string")
-            {
-                return validation_error(format!(
-                    "配置文件语法错误：检测到非法的字符串转义。\n\
-                     提示：在 Windows 路径末尾或字符串中使用反斜杠 '\\' 时：\n\
-                     1. 请使用双反斜杠转义，例如: \"D:\\\\CNWei\\\\CNW\\\\Rust\\\\\"\n\
-                     2. 或使用 Lua 原始字符串 (Raw String)，例如: [[D:\\CNWei\\CNW\\Rust\\]]\n\
-                     底层错误: {}",
-                    message
-                ));
-            }
-        }
-        _ => {}
-    }
-    err
-}

 /// 全局统一的 `Result` 别名，默认错误类型为 [`Error`]。
 pub type Result<T, E = Error> = std::result::Result<T, E>;

+/// 名称所属的类别，用于区分命令名 / 环境变量名 / 别名的校验与报错
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NameKind {
+    Command,
+    EnvVar,
+    Alias,
+}
+
+impl fmt::Display for NameKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Command => "命令名",
+            Self::EnvVar => "环境变量名",
+            Self::Alias => "别名",
+        })
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum Error {
    #[error("初始化 Lua 沙箱失败: {0}")]
    LuaInit(#[source] mlua::Error),
-    #[error("构建 LuaRuntime 异常")]
-    BuildError,
+
+    // #[error("构建 LuaRuntime 异常")]
+    // BuildError,
+    #[error("{kind}非法: {reason}")]
+    InvalidName { kind: NameKind, reason: String },
+
+    #[error("别名 '{name}' 存在循环引用")]
+    AliasCycle { name: String },
+
+    #[error("别名展开层级过深（超过 {max} 层）")]
+    AliasTooDeep { max: usize },
+
+    #[error("{0}")]
+    ContainsNul(String),
+
+    /// 值的结构不合法（数组空洞、字典键、嵌套过深等）
+    #[error("{0}")]
+    ParseError(String),
+
+    #[error("目录布局解析失败: {0}")]
+    Layout(String),
+
+    #[error("注册全局变量 '{name}' 失败: {source}")]
+    RegisterGlobal {
+        name: &'static str,
+        #[source]
+        source: mlua::Error,
+    },
+
+    #[error("{from} -> {to} 转换失败: {message}")]
+    EncodingError {
+        from: &'static str,
+        to: String,
+        message: String,
+    },
+    // 类型不符：Lua 值的类型与期望不符，用户应修改配置写法
+    #[error("字段 {field} 类型不符：期望 {expected}，实际是 {actual}")]
+    TypeMismatch {
+        field: String,
+        expected: &'static str,
+        actual: &'static str,
+    },
+
+    #[error("缺少必填字段 {field}")]
+    MissingField { field: String },

    ///读取脚本文件失败
    #[error("读取脚本文件失败 ({path}): {source}")]
@@ -79,31 +104,56 @@ pub enum Error {
    //     #[source]
    //     source: mlua::Error,
    // },
-
-    #[error("Lua 运行时未指定上下文错误: {0}")]
-    LuaError(#[from] mlua::Error),
+    #[error("Lua 适配层错误: {0}")]
+    LuaAdapter(#[from] mlua::Error),

    // #[error("设置 {0} 环境变量失败")]
    // SetMirrorDir(String),
-
    /// 用户自定义扩展错误，用于包装第三方插件产生的错误。
    #[error("用户自定义扩展错误: {0}")]
    Other(#[source] Box<dyn std::error::Error + Send + Sync>),
 }
-
+/// 出站转换：core 自己的错误 -> Lua 世界能看懂的错误。
+///
+/// 触发时机：函数返回 `mlua::Result<T>`，但 `?` 的表达式返回 `crate::Result<T>`。
+/// 有了这个 impl，Lua 边界的代码只写 `?`，不需要在每个调用点手工构造 mlua 错误。
+impl From<Error> for mlua::Error {
+    fn from(err: Error) -> Self {
+        match err {
+            // 本来就是 mlua 的错误：原样透传，保留错误种类与位置信息
+            Error::LuaInit(e) | Error::LuaAdapter(e) => e,
+            // source 自带 chunk 名（set_name 已写入），所以这里直接透传内层错误
+            Error::LuaRuntime { source, .. } => source,
+            Error::EncodingError { from, to, message } => mlua::Error::FromLuaConversionError {
+                from,
+                to,
+                message: Some(message),
+            },
+            Error::TypeMismatch {
+                field,
+                expected, actual,
+            } => mlua::Error::FromLuaConversionError {
+                from: actual,
+                to: expected.into(),
+                message: Some(format!("字段 '{field}' 类型不符")),
+            },
+            Error::MissingField { field } => {
+                mlua::Error::RuntimeError(format!("缺少必填字段 {field}"))
+            }
+            // 其余是 core 的领域错误：翻译成 Lua 侧可见的运行时错误，
+            // to_string() 由 thiserror 的 #[error("...")] 生成，也就是用户看到的中文
+            other => mlua::Error::RuntimeError(other.to_string()),
+        }
+    }
+}

 /// 将 MirrorTarget 构建为 Command 时可能触发的阻断性错误
 #[derive(Debug, Clone)]
 pub enum TargetExecutionError {
    /// 多版本工具未激活版本 (current == None)
-    UnselectedVersion {
-        tool: String,
-    },
+    UnselectedVersion { tool: String },
    /// 目标可执行文件物理不存在
-    NotFound {
-        tool: String,
-        path: PathBuf,
-    },
+    NotFound { tool: String, path: PathBuf },
 }

 impl fmt::Display for TargetExecutionError {
@@ -117,14 +167,65 @@ impl fmt::Display for TargetExecutionError {
                )
            }
            Self::NotFound { tool, path } => {
-                write!(
-                    f,
-                    "工具 '{}' 的目标程序不存在: {:?}",
-                    tool, path
-                )
+                write!(f, "工具 '{}' 的目标程序不存在: {}", tool, path.display())
            }
        }
    }
 }

 impl std::error::Error for TargetExecutionError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 领域错误出站后，原始的中文提示必须还在
+    #[test]
+    fn config_error_converts_to_lua_error_with_payload() {
+        let lua_err: mlua::Error = Error::InvalidName {
+            kind: NameKind::Command,
+            reason: "不能为空".into(),
+        }
+        .into();
+        assert!(
+            lua_err.to_string().contains("不能为空"),
+            "unexpected message: {lua_err}"
+        );
+    }
+
+    /// Lua 原生错误出站时要原样透传，不能被包成 RuntimeError 丢掉种类
+    #[test]
+    fn native_lua_error_passes_through() {
+        let lua_err: mlua::Error =
+            Error::LuaAdapter(mlua::Error::RuntimeError("boom".into())).into();
+        assert!(
+            lua_err.to_string().contains("boom"),
+            "unexpected message: {lua_err}"
+        );
+    }
+    #[test]
+    fn conversion_error_keeps_kind() {
+        let lua_err: mlua::Error = Error::EncodingError {
+            from: "LuaString",
+            to: "OsString".into(),
+            message: "坏字节".into(),
+        }
+        .into();
+        assert!(matches!(
+            lua_err,
+            mlua::Error::FromLuaConversionError { .. }
+        ));
+    }
+
+    #[test]
+    fn missing_field_message_has_no_duplication() {
+        let lua_err: mlua::Error = Error::MissingField {
+            field: "home".into(),
+        }
+        .into();
+        // mlua 会给 RuntimeError 加 "runtime error: " 前缀，所以只断言内容正确且不重复
+        let message = lua_err.to_string();
+        assert_eq!(message.matches("缺少必填字段").count(), 1, "{message}");
+        assert!(message.contains("home"), "{message}");
+    }
+}
@@ -0,0 +1,124 @@
+use crate::{Error, Result};
+use std::env;
+use std::path::{Path, PathBuf};
+use tracing::debug;
+pub struct Layout {
+    pub base_dir: PathBuf,
+    pub target_name: String,
+}
+
+impl Layout {
+    /// 自动解析目录布局：
+    /// 1. 优先使用环境变量 MIRROR_HOME
+    /// 2. 兜底回退到当前垫片可执行文件所在目录推断 (exe -> bin -> root)
+    pub fn from(current_exe: &Path) -> Result<Self> {
+        let target_name = current_exe
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .ok_or_else(|| {
+                Error::Layout(format!(
+                    "无法从路径 [{}] 提取有效的程序名称",
+                    current_exe.display()
+                ))
+            })?
+            .to_lowercase();
+
+        // 策略 1: 环境变量优先
+        if let Ok(home_val) = env::var("MIRROR_HOME") {
+            let trimmed = home_val.trim();
+            if !trimmed.is_empty() {
+                debug!(home = %trimmed, "检测到 MIRROR_HOME，采用环境变量配置");
+
+                return Self::from_base_dir(PathBuf::from(trimmed), target_name);
+            }
+        }
+
+        // 策略 2: 相对路径自动推断兜底
+        debug!("未配置 MIRROR_HOME，尝试从当前可执行文件路径推断根目录");
+        Self::from_executable(current_exe, target_name)
+    }
+
+    /// 基于确定的根目录构建完整布局
+    fn from_base_dir(base_dir: PathBuf, target_name: String) -> Result<Self> {
+        if !base_dir.is_dir() {
+            debug!("指定的根目录不存在或不是有效目录: [{}]", base_dir.display());
+            return Err(Error::Layout(format!(
+                "指定的根目录不存在或不是有效目录: [{}]",
+                base_dir.display()
+            )));
+        }
+
+        let mirror_file = base_dir.join("mirror.lua");
+        if !mirror_file.is_file() {
+            debug!(
+                "根目录 [{}] 下未找到核心配置文件 [mirror.lua]",
+                base_dir.display()
+            );
+            return Err(Error::Layout(format!(
+                "根目录 [{}] 下未找到核心配置文件 [mirror.lua]",
+                base_dir.display()
+            )));
+        }
+
+        Ok(Self {
+            base_dir,
+            target_name,
+        })
+    }
+
+    /// 从当前可执行文件解析 shim 安装目录布局
+    fn from_executable(exe_path: &Path, target_name: String) -> Result<Self> {
+        // let exe_path = exe_path.as_ref();
+        let start_dir = exe_path.parent().ok_or_else(|| {
+            Error::Layout(format!("无法获取程序 [{}] 的所在目录", exe_path.display()))
+        })?;
+
+        debug!("可执行程序所在目录: {}", start_dir.display());
+
+        // let base_dir = start_dir
+        //     .parent()
+        //     .with_context(|| format!("无法获取 bin 目录 [{}] 的父级 root 目录", bin_dir.display()))?
+        //     .to_path_buf();
+
+        // 2. 向上回溯寻找 mirror.lua 锚点
+        let base_dir = find_base_dir_by_anchor(start_dir).ok_or_else(|| {
+            Error::Layout(format!(
+                "路径推导失败：从 [{}] 向上逐级回溯均未找到 [mirror.lua]。\n\
+                提示: 请确保程序位于包含 mirror.lua 的项目内，或配置 MIRROR_HOME 环境变量。",
+                start_dir.display()
+            ))
+        })?;
+        debug!("成功探测到 base_dir 目录 {}", base_dir.display());
+
+        // 此时 base_dir 下必然有 mirror.lua，直接构建
+        Ok(Self {
+            base_dir,
+            target_name,
+        })
+    }
+}
+/// 向上查找包含 mirror.lua 的根目录
+fn find_base_dir_by_anchor(start_dir: &Path) -> Option<PathBuf> {
+    let mut current = Some(start_dir);
+
+    // 最大向上回溯层级（例如 3~4 层，防止死循环跑到磁盘根目录甚至网络挂载点）
+    let mut depth = 0;
+    const MAX_DEPTH: usize = 4;
+
+    while let Some(dir) = current {
+        if depth > MAX_DEPTH {
+            debug!("超出最大向上回溯层级：4");
+            break;
+        }
+
+        // 只要当前目录下有 mirror.lua，这里就是真正的 base_dir！
+        if dir.join("mirror.lua").is_file() {
+            return Some(dir.to_path_buf());
+        }
+
+        current = dir.parent();
+        depth += 1;
+    }
+
+    None
+}
@@ -0,0 +1,3 @@
+pub(crate) mod layout;
+pub(crate) mod path;
+pub use layout::Layout;
@@ -0,0 +1,10 @@
+use std::path::Path;
+
+/// 将 Path 转换为适合 Lua 使用的安全字符串路径
+pub fn normalize_path_for_lua(path: &Path) -> String {
+    // 自动将 Windows UNC 规范路径转回传统路径
+    let simplified = dunce::simplified(path);
+    simplified.to_string_lossy().replace('\\', "/")
+}
+
+
@@ -1,72 +0,0 @@
-use anyhow::{Context, Result, bail};
-use std::env;
-use std::path::{Path, PathBuf};
-use tracing::debug;
-pub struct Layout {
-    pub base_dir: PathBuf,
-    pub bin_dir: PathBuf,
-    pub target_name: String,
-}
-
-impl Layout {
-    /// 自动解析目录布局：
-    /// 1. 优先使用环境变量 MIRROR_HOME
-    /// 2. 兜底回退到当前垫片可执行文件所在目录推断 (exe -> bin -> root)
-    pub fn from(current_exe: &Path) -> Result<Self> {
-        let target_name = current_exe
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .with_context(|| format!("无法从路径 [{}] 提取有效的程序名称", current_exe.display()))?
-            .to_lowercase();
-
-        // 策略 1: 环境变量优先
-        if let Ok(home_val) = env::var("MIRROR_HOME") {
-            let trimmed = home_val.trim();
-            if !trimmed.is_empty() {
-
-                debug!(home = %trimmed, "检测到 MIRROR_HOME，采用环境变量配置");
-
-                return Self::from_base_dir(PathBuf::from(trimmed), target_name);
-            }
-        }
-
-        // 策略 2: 相对路径自动推断兜底
-        debug!("未配置 MIRROR_HOME，尝试从当前可执行文件路径推断根目录");
-        Self::from_executable(current_exe, target_name)
-    }
-
-    /// 基于确定的根目录构建完整布局
-    fn from_base_dir(base_dir: PathBuf, target_name: String) -> Result<Self> {
-        if !base_dir.is_dir() {
-            bail!("指定的根目录不存在或不是有效目录: [{}]", base_dir.display());
-        }
-
-        let bin_dir = base_dir.join("bin");
-
-        Ok(Self {
-            base_dir,
-            bin_dir,
-            target_name,
-        })
-    }
-
-    /// 从当前可执行文件解析 shim 安装目录布局
-    fn from_executable(exe_path: &Path, target_name: String) -> Result<Self> {
-        // let exe_path = exe_path.as_ref();
-        let bin_dir = exe_path
-            .parent()
-            .with_context(|| format!("无法获取程序 [{}] 的父级 bin 目录", exe_path.display()))?
-            .to_path_buf();
-
-        debug!("bin_dir目录 {}", bin_dir.display());
-
-        let base_dir = bin_dir
-            .parent()
-            .with_context(|| format!("无法获取 bin 目录 [{}] 的父级 root 目录", bin_dir.display()))?
-            .to_path_buf();
-
-        debug!("base_dir 目录 {}", base_dir.display());
-
-        Self::from_base_dir(base_dir, target_name)
-    }
-}
@@ -1,20 +1,18 @@
+mod args;
+mod config;
 mod error;
-mod layout;
-mod logger;
-mod plugins;
-mod runtime;
-mod utils;
-mod validators;
-mod model;
+mod fs;
+mod logging;
+mod lua;

-pub use layout::Layout;
+pub use config::{
+    load_mirror_spec, parse_command_name, MirrorRegistry, MirrorSpec, MirrorTarget, Target,
+    TargetConfig, TargetSpec,
+};
+pub use fs::Layout;
 // pub use mirror_shim::mirror::Mirror;
-pub use runtime::LuaRuntime;
+pub use logging::{LogConfig, LogLevel, init_logging_from};
+pub use lua::{register_basics, LuaRuntime};

-pub use logger::{LogConfig, LogLevel, init_logging_from};
-pub use plugins::register_basics;
-pub use utils::normalize_path_for_lua;
-pub use validators::validate_command_name;
 // 把 Result 和 Error 提升到根命名空间，给外部带来极致便利
-pub use error::{Error, Result,validation_error,conversion_err,TargetExecutionError};
-pub use model::TargetConfig;
+pub use error::{Error, NameKind, Result, TargetExecutionError};
@@ -1,4 +1,4 @@
-use crate::Layout;
+use crate::fs::Layout;
 use std::convert::Infallible;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -0,0 +1,5 @@
+pub mod runtime;
+pub mod plugins;
+
+pub use plugins::register_basics;
+pub use runtime::LuaRuntime;
@@ -1,7 +1,8 @@
 use crate::error::{Error, Result};
-use crate::{Layout, normalize_path_for_lua};
+use crate::fs::{Layout, path::normalize_path_for_lua};
 use mlua::{Lua, Table, Value};
-use std::env;
+use std::path::PathBuf;
+use std::{env, fs};
 use tracing::{debug, warn};

 const MIRROR_DIR: &str = "__MIRROR_DIR__";
@@ -12,13 +13,19 @@ pub fn register_basics(lua: &Lua, layout: &Layout) -> Result<()> {
    register_mirror_dir(lua, &base_dir)?;
    register_get_env(lua)?;
    setup_require(lua, &base_dir)?;
+    register_mr_version(lua)?;
    Ok(())
 }

 /// 注入全局锚点变量
 pub fn register_mirror_dir(lua: &Lua, base_dir: &str) -> Result<()> {
    debug!("设置 {MIRROR_DIR} 环境变量");
-    lua.globals().set(MIRROR_DIR, base_dir)?;
+    lua.globals()
+        .set(MIRROR_DIR, base_dir)
+        .map_err(|e| Error::RegisterGlobal {
+            name: MIRROR_DIR,
+            source: e,
+        })?;
    // .context(format!("设置 {MIRROR_DIR} 环境变量失败"))?;
    Ok(())
 }
@@ -109,3 +116,52 @@ pub fn setup_require(lua: &Lua, base_dir: &str) -> Result<()> {

    Ok(())
 }
+
+/// 向 Lua 全局环境注册 `mr` 模块及其原生辅助函数
+pub fn register_mr_version(lua: &Lua) -> Result<()> {
+    // 1. 获取或创建全局 `mr` Table
+    let globals = lua.globals();
+    let mr_table = match globals.get::<Value>("mr")? {
+        Value::Table(t) => t,
+        _ => {
+            let t = lua.create_table()?;
+            globals.set("mr", t.clone())?;
+            t
+        }
+    };
+
+    // 2. 实现 mr.version(home, version_file) -> Option<String>
+    // 规则：
+    // - version_file 为可选参数，缺省默认使用 ".version"
+    // - 文件不存在、空内容或读取失败时，安全返回 nil，绝不让 Lua 脚本崩盘
+    // - 自动 trim 掉末尾的 \r\n，仅提取纯净版本号
+    let version_fn = lua.create_function(
+        |_lua, (home_str, version_file_opt): (String, Option<String>)| {
+            let version_filename = version_file_opt
+                .filter(|s| !s.trim().is_empty())
+                .unwrap_or_else(|| ".version".to_string());
+
+            let mut target_path = PathBuf::from(home_str);
+            target_path.push(version_filename);
+
+            // 读取文件并安全修剪
+            match fs::read_to_string(&target_path) {
+                Ok(content) => {
+                    let trimmed = content.trim();
+                    if trimmed.is_empty() {
+                        Ok(None::<String>) // 文件内容为空字符串时，视为未设置版本
+                    } else {
+                        Ok(Some(trimmed.to_string()))
+                    }
+                }
+                // 常见错误（NotFound 等）直接返回 nil，不抛出 Lua error
+                Err(_) => Ok(None::<String>),
+            }
+        },
+    )?;
+
+    // 3. 挂载到 mr 表
+    mr_table.set("version", version_fn)?;
+
+    Ok(())
+}
@@ -1,4 +1,4 @@
-use crate::{Error, Result};
+use crate::error::{Error, Result};
 use mlua::{FromLua, Lua, StdLib, Value};
 use std::fs;
 use std::path::Path;
@@ -98,18 +98,21 @@ mod tests {
    use super::*;
    use crate::Layout;

-    fn test_layout() -> Layout {
-        let root = std::env::temp_dir().join("rshim-test-layout");
-        Layout {
-            base_dir: root.clone(),
-            bin_dir: root.join("bin"),
-            target_name: "muna".to_string(),
-        }
+    /// 测试用运行时：和线上一样注册宿主函数（get_env / require 包装等）
+    fn test_runtime() -> LuaRuntime {
+        let layout = Layout {
+            base_dir: std::env::temp_dir().join("mirror-core-test-layout"),
+            target_name: "mirror-shim".to_string(),
+        };
+        LuaRuntime::builder()
+            .with(|lua| crate::lua::register_basics(lua, &layout))
+            .build()
+            .unwrap()
    }

    #[test]
    fn missing_module_require_returns_nil() {
-        let runtime = LuaRuntime::builder().build().unwrap();
+        let runtime = test_runtime();
        let value: Value = runtime
            .lua
            .load(r#"return require("rshim_test_no_such_module")"#)
@@ -120,7 +123,7 @@ mod tests {

    #[test]
    fn builtin_module_require_still_works() {
-        let runtime = LuaRuntime::builder().build().unwrap();
+        let runtime = test_runtime();
        let value: Value = runtime
            .lua
            .load(r#"return pcall(require, "string")"#)
@@ -131,7 +134,7 @@ mod tests {

    #[test]
    fn get_env_returns_split_table() {
-        let runtime = LuaRuntime::builder().build().unwrap();
+        let runtime = test_runtime();
        let value: Value = runtime
            .lua
            .load(r#"return get_env("PATH")"#)
@@ -158,7 +161,7 @@ mod tests {

    #[test]
    fn get_env_missing_returns_empty_table() {
-        let runtime = LuaRuntime::builder().build().unwrap();
+        let runtime = test_runtime();
        let value: Value = runtime
            .lua
            .load(r#"return get_env("RSHIM_TEST_NO_SUCH_VAR_12345")"#)
@@ -169,57 +172,4 @@ mod tests {
            other => panic!("expected table, got {}", other.type_name()),
        }
    }
-
-    // #[test]
-    // fn path_with_get_env_joins_without_quote_error() {
-    //     // 复现用户场景：PATH = { base_dir .. "/tools/numa", get_env("PATH") }
-    //     // 宿主 PATH 即使含双引号，也应拆分后正常拼接，而不是报错
-    //     let runtime = LuaRuntime::new(&test_layout()).unwrap();
-    //     let cfg: Mirror = runtime
-    //         .lua
-    //         .load(
-    //             r#"
-    //             return {
-    //                 target = __SHIM_DIR__ .. "/tools/numa/numa.exe",
-    //                 args = { "--help" },
-    //                 env = {
-    //                     PATH = { __SHIM_DIR__ .. "/tools/numa", get_env("PATH") }
-    //                 }
-    //             }
-    //             "#,
-    //         )
-    //         .eval()
-    //         .unwrap();
-    //
-    //     let path = cfg.env.get("PATH").unwrap().to_str().unwrap();
-    //     let prefix = std::env::temp_dir()
-    //         .join("rshim-test-layout")
-    //         .to_string_lossy()
-    //         .replace('\\', "/")
-    //         + "/tools/numa;";
-    //     assert!(path.starts_with(&prefix), "unexpected PATH: {path}");
-    //
-    //     // 宿主 PATH 的段应被附加在配置前缀之后
-    //     let host = std::env::var("PATH").unwrap_or_default();
-    //     if !host.is_empty() {
-    //         let host_first = std::env::split_paths(&host)
-    //             .next()
-    //             .unwrap()
-    //             .to_string_lossy()
-    //             .into_owned();
-    //         assert!(
-    //             path.contains(&host_first),
-    //             "missing host PATH segment: {host_first}"
-    //         );
-    //     }
-    //
-    //     // 宿主 PATH 里引号包裹的畸形段（如 "D:\\...\\bin;"）应被原样保留，
-    //     // 而不是让整个配置加载失败
-    //     if host.contains('"') {
-    //         assert!(
-    //             path.contains('"'),
-    //             "quoted host segments should be preserved"
-    //         );
-    //     }
-    // }
 }
@@ -1,127 +0,0 @@
-use std::ffi::OsString;
-use mlua::{FromLua, Lua, LuaString, Value};
-use std::path::PathBuf;
-use crate::utils::lua_string_2_os_string;
-use crate::validation_error;
-use crate::validators::ensure_no_nul;
-
-/// 目标可执行文件的定位配置（支持静态路径与多版本 Table）
-#[derive(Debug, Clone)]
-pub enum TargetConfig{
-    /// 静态单版本工具
-    Static(PathBuf),
-    /// 多版本管理
-    Versioned{
-        /// 工具主根目录（供 mr use 扫描候选版本）
-        home:PathBuf,
-        /// 版本真相源文件名（如 ".version"，可选，默认 ".version"）
-        version_file:Option<String>,
-        /// 当前激活版本的可执行文件完整路径（若未激活或不存在则为 None）
-        current:Option<PathBuf>,
-    }
-}
-impl Default for TargetConfig {
-    fn default() -> Self {
-        TargetConfig::Static(PathBuf::default())
-    }
-}
-impl TargetConfig {
-    /// 垫片程序（mirror-shim）专用快速通道：提取最终可执行路径
-    ///
-    /// - Static: 返回自身路径
-    /// - Versioned: 返回 current 路径（若未激活则返回 None）
-
-    pub fn executable_path(&self) -> Option<&PathBuf> {
-        match self {
-            TargetConfig::Static(path) => Some(path),
-            TargetConfig::Versioned { current, .. } => current.as_ref(),
-        }
-    }
-    
-    /// 管理程序（mr-cli）专用辅助方法：判断是否支持多版本
-    pub fn is_versioned(&self) -> bool {
-        matches!(self, TargetConfig::Versioned { .. })
-    }
-}
-
-impl FromLua for TargetConfig {
-    fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
-        match value {
-            // 分支 1：静态单版本工具 target = "..."
-            Value::String(s) => {
-                let os_str = lua_string_2_os_string(&s)?;
-                ensure_no_nul(&"target", &os_str)?;
-                Ok(TargetConfig::Static(PathBuf::from(os_str)))
-            }
-
-            // 分支 2：多版本管理工具 target = { home = "...", ... }
-            Value::Table(table) => {
-                // 1. home (必填字段)
-                let home = match table.get::<Option<Value>>("home")? {
-                    Some(Value::String(s)) => {
-                        let os_str = lua_string_2_os_string(&s)?;
-                        ensure_no_nul(&"target.home", &os_str)?;
-                        PathBuf::from(os_str)
-                    }
-                    None | Some(Value::Nil) => {
-                        return Err(validation_error("多版本 target 表缺少必填字段 'home'"));
-                    }
-                    Some(other) => {
-                        return Err(validation_error(format!(
-                            "target.home 需为路径字符串，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                // 2. version_file (选填字段，未填或 nil 时为 None)
-                let version_file = match table.get::<Option<Value>>("version_file")? {
-                    Some(Value::String(s)) => {
-                        let os_str = lua_string_2_os_string(&s)?;
-                        ensure_no_nul(&"target.version_file", &os_str)?;
-                        Some(os_str.to_string_lossy().into_owned())
-                    }
-                    None | Some(Value::Nil) => None,
-                    Some(other) => {
-                        return Err(validation_error(format!(
-                            "target.version_file 需为文件名字符串，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                // 3. current (选填/可为 nil，表示未激活或当前未指定版本)
-                let current = match table.get::<Option<Value>>("current")? {
-                    Some(Value::String(s)) => {
-                        let os_str = lua_string_2_os_string(&s)?;
-                        ensure_no_nul(&"target.current", &os_str)?;
-                        Some(PathBuf::from(os_str))
-                    }
-                    // Lua 侧 ver 为 nil 时，current 拼出的也是 nil，此时合法解析为 None
-                    None | Some(Value::Nil) => None,
-                    Some(other) => {
-                        return Err(validation_error(format!(
-                            "target.current 需为有效路径字符串或 nil，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                Ok(TargetConfig::Versioned {
-                    home,
-                    version_file,
-                    current,
-                })
-            }
-
-            Value::Nil => Err(validation_error(
-                "缺少必填字段 target（应为字符串路径或多版本配置表）",
-            )),
-            other => Err(validation_error(format!(
-                "target 需为有效路径字符串或多版本配置表，实际类型是 {}",
-                other.type_name()
-            ))),
-        }
-    }
-}
-
@@ -1,65 +0,0 @@
-use std::fmt;
-use crate::error::validation_error;
-use mlua::Value;
-
-pub fn validate_command_name(name: &Value) -> mlua::Result<String> {
-    let name_str = match name {
-        Value::String(s) => s
-            .to_str()
-            .map_err(|_| validation_error("子命令名称必须是合法的 UTF-8 字符串"))?
-            .to_string(),
-        other => {
-            return Err(validation_error(format!(
-                "命令行键名类型错误：期望 string，实际是 {}",
-                other.type_name()
-            )));
-        }
-    };
-    let trimmed = name_str.trim();
-    if trimmed.is_empty() {
-        return Err(validation_error("子命令名称不能为空字符串"));
-    }
-    // 2. 禁止包含空格与不可见控制符（否则 shell 与 clap 无法正确定位）
-    if name_str.contains(|c: char| c.is_whitespace()) {
-        return Err(validation_error(format!(
-            "子命令名称 [{name_str}] 非法：命令名不能包含空格或空白字符"
-        )));
-    }
-
-    if name_str.contains('=') {
-        return Err(validation_error(format!(
-            "子命令名称 [{}] 不能包含 '='",
-            name_str
-        )));
-    }
-    if name_str.contains('\0') {
-        return Err(validation_error(format!(
-            "子命令名称 [{}] 不能包含 NUL 字符",
-            name_str
-        )));
-    }
-    Ok(name_str)
-}
-pub fn ensure_no_nul(context: &impl fmt::Display, os_str: &std::ffi::OsStr) -> mlua::Result<()> {
-    #[cfg(unix)]
-    {
-        use std::os::unix::ffi::OsStrExt;
-        if os_str.as_bytes().contains(&0) {
-            return Err(conversion_error(format!(
-                "{} 的值不能包含 NUL 字符",
-                context
-            )));
-        }
-    }
-    #[cfg(windows)]
-    {
-        use std::os::windows::ffi::OsStrExt;
-        if os_str.encode_wide().any(|c| c == 0) {
-            return Err(validation_error(format!(
-                "{} 的值不能包含 NUL 字符",
-                context
-            )));
-        }
-    }
-    Ok(())
-}
@@ -10,7 +10,6 @@ return {
    -- 1. 标准相对路径 + 正斜杠拼接 (最推荐，绿色便携)
    ---------------------------------------------------
    ["numa"] = {
-        home="",
        target = base_dir .. "/tools/numa/numa.exe",
        -- 追加参数
        args = { "--help" },
@@ -0,0 +1,39 @@
+---
+--- Generated by EmmyLua(https://github.com/EmmyLua)
+--- Created by Administrator.
+--- DateTime: 2026/9/10 20:16
+---
+
+-- tools/node.lua
+local home = base_dir .. "/tools/node"
+local version_file = ".version"
+
+-- 安全读取当前激活版本：未激活或文件不存在时返回 nil，不抛出异常
+local ver = mr.version(home, version_file)
+
+return {
+    -- 1. target 配置为 Table，自动对应 Rust 侧的 TargetConfig::Versioned
+    target = {
+        home = home,
+        version_file = version_file,
+        -- 若版本未激活，current 为 nil；若激活，则拼出绝对路径
+        current = ver and (home .. "/" .. ver .. "/node.exe") or nil
+    },
+
+    -- 2. 默认追加参数
+    args = {},
+
+    -- 3. 别名映射（mr: 前缀可直接展开）
+    aliases = {
+        ["v"] = { "--version" },
+    },
+
+    -- 4. 环境变量联动：将对应版本的 bin 目录前置到 PATH
+    env = {
+        NODE_HOME = ver and (home .. "/" .. ver) or "",
+        PATH = {
+            ver and (home .. "/" .. ver) or "",
+            get_env("PATH")
+        }
+    }
+}
@@ -0,0 +1,25 @@
+use mirror_core::MirrorTarget;
+use std::ffi::OsString;
+use std::path::Path;
+use std::process::Command;
+use tracing::debug;
+pub fn to_command<P>(spec: &MirrorTarget, target: P, final_args: &[OsString]) -> Command
+where
+    P: AsRef<Path>,
+{
+    let mut cmd = Command::new(target.as_ref());
+
+    // 2. 传入预打平的别名字典，查表并展开所有以 `mr:` 为前缀的别名
+    // let final_args = self.resolve_args(combined_args);
+    debug!("拼接后的命令行参数{:?}", final_args);
+    // 3. 将解析展开后的无环参数一次性注入 Command
+    cmd.args(final_args);
+
+    // 4. 注入配置好的环境变量
+    for (key, val) in &spec.env {
+        // 直接应用环境变量（Lua 端已经处理好字符串拼接或列表合并）
+        cmd.env(key, val);
+    }
+
+    cmd
+}
@@ -1,4 +1,4 @@
-use crate::mirror::MirrorRegistry;
+use mirror_core::MirrorRegistry;
 use crate::sys::{
    ERROR_ELEVATION_REQUIRED, EXIT_FAILED_LOAD_SHIM, EXIT_FAILED_SPAWN_PROG, EXIT_FAILED_WAIT_PROG,
    EXIT_PROG_TERMINATED, execute_elevated,
@@ -8,6 +8,7 @@ use std::env;
 use std::ffi::OsString;
 use std::process::exit;
 use tracing::{error, warn};
+use crate::command;

 pub fn run(layout: &Layout) -> i32 {
    let global_config = &layout.base_dir.join("mirror.lua");
@@ -62,17 +63,17 @@ pub fn run(layout: &Layout) -> i32 {
    let calling_args: Vec<_> = env::args_os().skip(1).collect();

    let combined_args = mr.args.iter().chain(calling_args.iter());
-
+    let final_args = mr.resolve_args(combined_args);
    // 构建 Command：复用 ShimConfig::to_command（含 args/env 注入），避免重复逻辑
-    let mut cmd = mr.to_command(target_path, combined_args);
+    let mut cmd = command::to_command(mr,target_path, &final_args);

    let mut child = match cmd.spawn() {
        Ok(v) => v,
        Err(e) if e.raw_os_error() == Some(ERROR_ELEVATION_REQUIRED) => {
            // 提权回退时需要完整参数：配置默认参数 + 调用方透传参数
-            let elevated_args: Vec<OsString> = cmd.get_args().map(|s| s.to_os_string()).collect();
+            // let elevated_args: Vec<OsString> = cmd.get_args().map(|s| s.to_os_string()).collect();

-            exit(execute_elevated(target_path, &elevated_args, Some(&mr.env)))
+            exit(execute_elevated(target_path, &final_args, Some(&mr.env)))
        }
        Err(e) => {
            error!(
@@ -1,14 +1,13 @@
 use crate::sys::*;
 use anyhow::Context;
-use mirror_core::{Layout, init_logging_from};
+use mirror_core::{init_logging_from, Layout};
 use std::{env, process::exit};
 use tracing::debug;

 mod executor;
-pub mod mirror;
 pub mod sys;
-pub mod utils;
 pub mod validators;
+pub mod command;

 fn main() {
    let current_exe = match env::current_exe().context("获取代理程序路径失败") {
@@ -1,180 +0,0 @@
-use crate::validators::LuaValidator;
-use anyhow::{Context, Result, bail};
-use mirror_core::validate_command_name;
-use mirror_core::{Layout, LuaRuntime, TargetConfig};
-use mirror_core::{TargetExecutionError, conversion_err, validation_error};
-use mlua::{FromLua, Lua, Table, Value};
-use std::collections::HashMap;
-use std::env;
-use std::ffi::OsString;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use tracing::{debug, trace};
-
-pub struct MirrorRegistry {
-    pub targets: HashMap<String, MirrorTarget>,
-}
-
-impl FromLua for MirrorRegistry {
-    fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {
-        let root_tbl = match value {
-            Value::Table(t) => t,
-            other => {
-                return Err(conversion_err(
-                    other.type_name(),
-                    "MirrorRegistry",
-                    format!(
-                        "mirror 全局注册表顶层必须是 Table，实际检测到: {}",
-                        other.type_name()
-                    ),
-                ));
-            }
-        };
-        let mut targets = HashMap::new();
-        for pair in root_tbl.pairs::<Value, Value>() {
-            let (key, entry) = pair?;
-
-            let target_name = validate_command_name(&key)?;
-            // 2. 校验 entry 是否是 Table
-            if !entry.is_table() {
-                return Err(conversion_err(
-                    entry.type_name(),
-                    "MirrorRegistry",
-                    format!(
-                        "目标工具 '{target_name}' 的配置必须是 Table，实际检测到: {}",
-                        entry.type_name()
-                    ),
-                ));
-            }
-            // 3. 直接交由子命令解析，外层负责补充错误上下文
-            let target_spec = MirrorTarget::from_lua(entry, lua).map_err(|err| {
-                validation_error(format!("目标工具 '{target_name}' 配置解析失败:\n{err}"))
-            })?;
-
-            targets.insert(target_name, target_spec);
-        }
-        Ok(Self { targets })
-    }
-}
-/// 单个目标程序的代理规格配置
-#[derive(Debug, Clone, Default)]
-pub struct MirrorTarget {
-    /// 目标程序可执行文件路径
-    pub target: TargetConfig,
-    /// 默认预设参数列表
-    pub args: Vec<OsString>,
-    /// 参数别名映射表（用于展开以 mr: 为前缀的别名）
-    pub aliases: HashMap<String, Vec<OsString>>,
-    /// 注入/覆盖的环境变量
-    pub env: HashMap<String, OsString>,
-}
-
-impl MirrorTarget {
-    /// 1. 核心参数路由解析（Delegation 到 Spec 的路由逻辑）
-    fn resolve_args<I, S>(&self, args: I) -> Vec<OsString>
-    where
-        I: IntoIterator<Item = S>,
-        S: AsRef<std::ffi::OsStr>,
-    {
-        let arg_iter = args.into_iter();
-
-        // 1. 预分配容量：利用迭代器的下限提示，避免多次 Realloc
-        let (lower_bound, _) = arg_iter.size_hint();
-        let mut expanded_args: Vec<OsString> = Vec::with_capacity(lower_bound);
-
-        for i in arg_iter {
-            let os_str = i.as_ref();
-
-            let arg_str = os_str.to_string_lossy();
-
-            // 检查参数是否带有 mr: 前缀
-            if let Some(alias_key) = arg_str.strip_prefix("mr:") {
-                // 如果在加载期打平好的字典中找到了对应的别名，直接展开追加
-                if let Some(alias_values) = self.aliases.get(alias_key) {
-                    expanded_args.extend(alias_values.iter().cloned());
-                } else {
-                    // 如果找不到对应的别名，按原样参数追加
-                    expanded_args.push(os_str.to_os_string());
-                }
-            } else {
-                // 普通参数，直接追加
-                expanded_args.push(os_str.to_os_string());
-            }
-        }
-        expanded_args
-    }
-
-    pub fn to_command<P, I, S>(&self, target: P, combined_args: I) -> Command
-    where
-        P: AsRef<Path>,
-        I: IntoIterator<Item = S>,
-        S: AsRef<std::ffi::OsStr>,
-    {
-        let mut cmd = Command::new(target.as_ref());
-
-        // 2. 传入预打平的别名字典，查表并展开所有以 `mr:` 为前缀的别名
-        let final_args = self.resolve_args(combined_args);
-        debug!("拼接后的命令行参数{:?}", final_args);
-        // 3. 将解析展开后的无环参数一次性注入 Command
-        cmd.args(&final_args);
-
-        // 4. 注入配置好的环境变量
-        for (key, val) in &self.env {
-            // 直接应用环境变量（Lua 端已经处理好字符串拼接或列表合并）
-            cmd.env(key, val);
-        }
-
-        cmd
-    }
-}
-
-impl FromLua for MirrorTarget {
-    fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {
-        // 脚本返回必须是一个 Table 变体
-        let table = match value {
-            Value::Table(t) => t,
-            _ => {
-                return Err(validation_error(format!(
-                    "期望得到一个 Lua Table 配置对象，实际是 {}",
-                    value.type_name()
-                )));
-            }
-        };
-
-        // 必填字段: target（严格限定为字符串，避免数字被 mlua 宽松转为字符串后掩盖错误）
-        let target = match table.get::<Option<Value>>("target")? {
-            None | Some(Value::Nil) => {
-                return Err(validation_error(
-                    "缺少必填字段 target（应为字符串路径或多版本配置表）",
-                ));
-            }
-            // Some(target_val) => LuaValidator::parse_target(&target_val)?,
-            Some(target_val) => TargetConfig::from_lua(target_val, lua)?,
-        };
-
-        // 可选字段: args（缺失或 nil 时默认空列表；保留空字符串参数，与提权路径的 "" 语义一致）
-        let args = match table.get::<Option<Value>>("args")? {
-            None | Some(Value::Nil) => Vec::new(),
-            Some(args_val) => LuaValidator::parse_args(&args_val)?,
-        };
-
-        // 可选字段: env（只允许缺失/nil，其他类型由 Option<Table> 转换报错，不再静默忽略）
-        let env = match table.get::<Option<Value>>("env")? {
-            None | Some(Value::Nil) => HashMap::new(),
-            Some(env_val) => LuaValidator::parse_env(&env_val)?,
-        };
-
-        // 可选字段: aliases（只允许缺失/nil，其他类型由 Option<Table> 转换报错，不再静默忽略）
-        let aliases = match table.get::<Option<Value>>("aliases")? {
-            None | Some(Value::Nil) => HashMap::new(),
-            Some(env_val) => LuaValidator::parse_aliases(&env_val)?,
-        };
-        // println!("环境变量结果：{:?}", env);
-        Ok(Self {
-            target,
-            args,
-            aliases,
-            env,
-        })
-    }
-}
@@ -1,539 +1,14 @@
-use anyhow::{Context, Result, anyhow};
-use mirror_core::{TargetConfig, validation_error};
-use mlua::{LuaString, Table, Value};
-use std::collections::{HashMap, HashSet};
+use anyhow::Context;
+use mlua::{Table, Value};
 use std::ffi::OsString;
-use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
-// use tinyjson::JsonValue;
-use crate::utils::{lua_string_2_os_string, parse_tokens};
-use tracing::debug;

-/// Lua 值校验器：针对不同上下文定义校验规则
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LuaValidator {
-    /// 目标程序路径：必须是字符串路径
-    Target,
-    /// 命令行参数元素：仅支持一维基础标量，禁止嵌套 Table
-    Args,
-    /// 环境变量值：支持基础标量及多维嵌套 Table（递归展平）
-    Env,
-    Aliases,
-}
-
-impl fmt::Display for LuaValidator {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Target => write!(f, "目标路径 (target)"),
-            Self::Args => write!(f, "命令行参数 (args)"),
-            Self::Env => write!(f, "环境变量 (env)"),
-            Self::Aliases => write!(f, "命令行别名 (aliases)"),
-        }
-    }
-}
-impl LuaValidator {
-    fn parse_sequence(&self, index: i64, item: &Value) -> mlua::Result<()> {
-        match item {
-            Value::String(_) | Value::Integer(_) | Value::Number(_) | Value::Boolean(_) => Ok(()),
-            Value::Table(tbl) => match self {
-                Self::Env | Self::Aliases => self.validate_sequence_table(tbl),
-                Self::Args => Err(validation_error(format!(
-                    "{} 仅支持一维数组，不能包含嵌套 Table,索引位置: {index}",
-                    self
-                ))),
-                Self::Target => Err(validation_error(format!("{} 仅支持字符串", self))),
-            },
-            other => Err(validation_error(format!(
-                "{} 第 {} 个元素类型无效: {}",
-                self,
-                index,
-                other.type_name()
-            ))),
-        }
-    }
-
-    /// 校验 Table 是否为严格连续的纯数组，并递归校验其内部元素
-    fn validate_sequence_table(&self, tbl: &Table) -> mlua::Result<()> {
-        let mut index = 1i64;
-
-        // 1. 顺序遍历连续整数索引 1..N
-        loop {
-            let item: Value = tbl.raw_get(index)?;
-            if matches!(&item, Value::Nil) {
-                break;
-            }
-            self.parse_sequence(index, &item)?;
-
-            index += 1;
-        }
-
-        // 2. 查漏：校验是否存在空洞索引或字典键 (Key-Value 键值对)
-        for pair in tbl.pairs::<Value, Value>() {
-            let (key, _) = pair?;
-            match key {
-                Value::Integer(i) if i >= 1 && i < index => {} // 已遍历放行
-                Value::Integer(_) => {
-                    return Err(validation_error(format!(
-                        "{} 第 {} 个元素为 nil 或不存在（请检查漏写引号或变量未定义）",
-                        self, index
-                    )));
-                }
-                _ => {
-                    return Err(validation_error(format!(
-                        "{} 必须是纯列表，不能包含键值对/字典结构",
-                        self
-                    )));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// 底层 NUL 字符跨平台安全检查
-    fn ensure_no_nul(context: &impl fmt::Display, os_str: &std::ffi::OsStr) -> mlua::Result<()> {
-        #[cfg(unix)]
-        {
-            use std::os::unix::ffi::OsStrExt;
-            if os_str.as_bytes().contains(&0) {
-                return Err(conversion_error(format!(
-                    "{} 的值不能包含 NUL 字符",
-                    context
-                )));
-            }
-        }
-        #[cfg(windows)]
-        {
-            use std::os::windows::ffi::OsStrExt;
-            if os_str.encode_wide().any(|c| c == 0) {
-                return Err(validation_error(format!(
-                    "{} 的值不能包含 NUL 字符",
-                    context
-                )));
-            }
-        }
-        Ok(())
-    }
-
-    /// 【纯粹数据转换与展开】将已通过校验的 Value 递归解析为 OsString 动态数组
-    fn collect_value_into(&self, value: &Value, out: &mut Vec<OsString>) -> mlua::Result<()> {
-        match value {
-            Value::Nil => {}
-            Value::String(s) => {
-                let os_str = lua_string_2_os_string(s)?;
-                match self {
-                    Self::Args | Self::Aliases => {
-                        if let Some(str_ref) = os_str.to_str() {
-                            // 使用 Tokenizer 切分空格与引号
-                            out.extend(parse_tokens(str_ref));
-                        } else {
-                            // 对于无法转为 UTF-8 的特殊二进制数据，作为整体追加
-                            out.push(os_str);
-                        }
-                    }
-                    Self::Env => {
-                        out.push(os_str);
-                    }
-                    Self::Target => {}
-                }
-            }
-            Value::Integer(i) => out.push(OsString::from(i.to_string())),
-            Value::Number(n) => {
-                tracing::warn!(%self, value = %n, "浮点数将按十进制格式转换为字符串");
-                out.push(OsString::from(n.to_string()));
-            }
-            Value::Boolean(b) => {
-                tracing::warn!(%self, value = %b, "布尔值将转换为字符串");
-                out.push(OsString::from(b.to_string()));
-            }
-            Value::Table(tbl) => {
-                let mut index = 1i64;
-                loop {
-                    let item: Value = tbl.raw_get(index)?;
-                    if matches!(item, Value::Nil) {
-                        break;
-                    }
-
-                    Self::collect_value_into(self, &item, out)?;
-                    index += 1;
-                }
-            }
-            _ => unreachable!("传入收集器的 Value 应已通过 validate 校验"),
-        }
-        Ok(())
-    }
-    fn parse_name(name: &Value) -> mlua::Result<String> {
-        let name_str = match name {
-            Value::String(s) => match s.to_str() {
-                Ok(str_ref) => str_ref.to_string(),
-                Err(_) => return Err(validation_error("环境变量名必须是合法的 UTF-8 字符串")),
-            },
-            other => {
-                return Err(validation_error(format!(
-                    "环境变量键名类型错误：期望 string，实际是 {}",
-                    other.type_name()
-                )));
-            }
-        };
-        if name_str.is_empty() {
-            return Err(validation_error("环境变量名不能为空"));
-        }
-        if name_str.contains('=') {
-            return Err(validation_error(format!(
-                "环境变量名 [{}] 不能包含 '='",
-                name_str
-            )));
-        }
-        if name_str.contains('\0') {
-            return Err(validation_error(format!(
-                "环境变量名 [{}] 不能包含 NUL 字符",
-                name_str
-            )));
-        }
-        Ok(name_str)
-    }
-    fn parse_val(&self, name: &str, value: &Value) -> mlua::Result<()> {
-        match value {
-            Value::Nil
-            | Value::String(_)
-            | Value::Integer(_)
-            | Value::Number(_)
-            | Value::Boolean(_) => Ok(()),
-            Value::Table(tbl) => self.validate_sequence_table(tbl),
-            other => Err(validation_error(format!(
-                "{} [{}]不支持 {} 类型, 仅支持 string/number/boolean 或嵌套数组",
-                self,
-                name,
-                other.type_name()
-            ))),
-        }
-    }
-}
-impl LuaValidator {
-    /// 解析并校验 `target`
-    pub fn parse_target(value: &Value) -> mlua::Result<TargetConfig> {
-        let ctx = Self::Target;
-        match value {
-            Value::String(s) => {
-                let os_str = lua_string_2_os_string(&s)?;
-                Self::ensure_no_nul(&ctx, &os_str)?;
-                Ok(TargetConfig::Static(PathBuf::from(os_str)))
-            }
-            // 分支 2：多版本动态工具 target = { home = "...", version_file = "...", current = "..." }
-            Value::Table(t) => {
-                // 1. 解析 home（必填）
-                let home_val = t.get::<Value>("home")?;
-                let home = match home_val {
-                    Value::String(ref s) => {
-                        let os_str = lua_string_2_os_string(s)?;
-                        Self::ensure_no_nul(&"target.home", &os_str)?;
-                        PathBuf::from(os_str)
-                    }
-                    Value::Nil => {
-                        return Err(validation_error("多版本 target 表缺少必填字段 'home'"));
-                    }
-                    other => {
-                        return Err(validation_error(format!(
-                            "target.home 需为有效路径字符串，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                // 2. 解析 version_file（选填，默认为 None，后续业务可 fallback 到 .version）
-                let version_file = match t.get::<Option<Value>>("version_file")? {
-                    Some(Value::String(ref s)) => {
-                        let os_str = lua_string_2_os_string(s)?;
-                        Self::ensure_no_nul(&"target.version_file", &os_str)?;
-                        Some(os_str.to_string_lossy().into_owned())
-                    }
-                    Some(Value::Nil) | None => None,
-                    Some(other) => {
-                        return Err(validation_error(format!(
-                            "target.version_file 应为文件名字符串，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                // 3. 解析 current（选填/可为 nil：未激活或找不到版本时允许为 None）
-                let current = match t.get::<Option<Value>>("current")? {
-                    Some(Value::String(ref s)) => {
-                        let os_str = lua_string_2_os_string(s)?;
-                        Self::ensure_no_nul(&"target.current", &os_str)?;
-                        Some(PathBuf::from(os_str))
-                    }
-                    // Lua 侧 ver 为 nil 时，current 计算结果即为 nil，合法放行
-                    Some(Value::Nil) | None => None,
-                    Some(other) => {
-                        return Err(validation_error(format!(
-                            "target.current 需为有效路径字符串或 nil，实际类型是 {}",
-                            other.type_name()
-                        )));
-                    }
-                };
-
-                Ok(TargetConfig::Versioned {
-                    home,
-                    version_file,
-                    current,
-                })
-            }
-            Value::Nil => Err(validation_error(
-                "缺少必填字段 target（应为字符串路径或多版本配置表）",
-            )),
-            other => Err(validation_error(format!(
-                "{} 需为有效的路径且类型必须是字符串或多版本配置表，实际类型是 {}",
-                ctx,
-                other.type_name()
-            ))),
-        }
-    }
-
-    /// 解析并校验 `args`
-    pub fn parse_args(value: &Value) -> mlua::Result<Vec<OsString>> {
-        {
-            debug!("args 配置已关闭 ");
-            #[cfg(not(feature = "args"))]
-            Ok(Vec::new())
-        }
-        #[cfg(feature = "args")]
-        {
-            debug!("args 配置已开启");
-            let ctx = Self::Args;
-            match value {
-                Value::Table(tbl) => {
-                    ctx.validate_sequence_table(tbl)?;
-
-                    let capacity = tbl.raw_len().min(128);
-
-                    let mut raw_parts = Vec::with_capacity(capacity);
-
-                    Self::collect_value_into(&ctx, value, &mut raw_parts)?;
-
-                    for part in &raw_parts {
-                        Self::ensure_no_nul(&ctx, &part)?;
-                    }
-                    Ok(raw_parts)
-                }
-                other => Err(validation_error(format!(
-                    "{} 必须是数组列表，实际类型是 {}",
-                    ctx,
-                    other.type_name()
-                )))?,
-            }
-        }
-    }
-
-    /// 校验环境变量名的合法性（Windows 约束：非空、不含 '='、不含 NUL）
-    fn parse_env_name(name: &Value) -> mlua::Result<String> {
-        Self::parse_name(name)
-    }
-
-    /// 解析、校验并拼接单个环境变量键值对 (`key`, `value`) -> (`OsString`)
-    fn parse_env_val(
-        context: &LuaValidator,
-        name: &str,
-        raw_val: &Value,
-    ) -> mlua::Result<OsString> {
-        context.parse_val(name, raw_val)?;
-
-        // let ctx = format!("{} [{}]", context, name);
-        let capacity = match raw_val {
-            Value::Table(t) => t.raw_len().min(128),
-            Value::Nil => 0,
-            _ => 1,
-        };
-
-        let mut parts = Vec::with_capacity(capacity);
-
-        Self::collect_value_into(&context, raw_val, &mut parts)?;
-        // context.collect_value_into(raw_val, &mut parts)?;
-
-        // 校验每个展开元素的 NUL 字符
-        for part in &parts {
-            Self::ensure_no_nul(&name, part)?;
-        }
-        // 3. 使用系统路径分隔符拼接数组列表
-        let joined_os_str = std::env::join_paths(parts).map_err(|e| {
-            validation_error(format!("{} 的值无法用系统路径分隔符拼接: {}", context, e))
-        })?;
-        Ok(joined_os_str)
-    }
-
-    /// 解析整个 `env` Table，直接返回安全的环境变量 Map
-    pub fn parse_env(value: &Value) -> mlua::Result<HashMap<String, OsString>> {
-        let ctx = Self::Env;
-
-        let Value::Table(tbl) = value else {
-            // 这里作为防御性校验，外部虽然 match 过了，但内层仍保持强类型安全
-            return Err(validation_error(format!(
-                "{} 必须是键值表 (table)，实际类型是 {}",
-                ctx,
-                value.type_name()
-            )));
-        };
-
-        let mut env_map = HashMap::new();
-        let mut n = 0i32;
-
-        for pair in tbl.pairs::<Value, Value>() {
-            n += 1;
-
-            let (raw_key, raw_val) = pair?;
-            debug!("env {} {}", n, raw_val.type_name());
-
-            // 1. 解析并校验 Key，拿到安全的 String
-            let key = Self::parse_env_name(&raw_key)?;
-
-            // 2. 借用 &name 传递给 Value 解析器作为上下文
-            let val = Self::parse_env_val(&ctx, &key, &raw_val)?;
-
-            env_map.insert(key, val);
-        }
-
-        Ok(env_map)
-    }
-}
-
-impl LuaValidator {
-    /// 校验环境变量名的合法性（Windows 约束：非空、不含 '='、不含 NUL）
-    fn parse_aliases_name(name: &Value) -> mlua::Result<String> {
-        Self::parse_name(name)
-    }
-    fn parse_aliases_val(
-        context: &LuaValidator,
-        name: &str,
-        raw_val: &Value,
-    ) -> mlua::Result<Vec<OsString>> {
-        context.parse_val(name, raw_val)?;
-
-        // let ctx = format!("{} [{}]", context, name);
-        // 预估容量：标量为 1，表取其实际长度（设置上限以防止异常输入）
-        let capacity = match raw_val {
-            Value::Table(t) => (t.raw_len() as usize).min(16),
-            Value::Nil => 0,
-            _ => 1,
-        };
-
-        let mut parts = Vec::with_capacity(capacity);
-        Self::collect_value_into(context, raw_val, &mut parts)?;
-        Ok(parts)
-    }
-    /// 解析并打平别名表 (aliases)
-    /// - 支持输入为 Nil / None / Table
-    /// - 别名的值支持：String, Number, Boolean, Nil, " " 空白串, Table(连续数组)
-    /// - 字符串作为整体参数保存，仅做 trim() 清理首尾空格，不按空格拆分
-    /// - 包含拓扑展开与死环检测
-    pub fn parse_aliases(value: &Value) -> mlua::Result<HashMap<String, Vec<OsString>>> {
-        let ctx = Self::Aliases;
-        // 1. 处理 nil / None 的情况，直接返回空 HashMap
-        let Value::Table(table) = value else {
-            return Err(validation_error(format!(
-                "{} 必须是键值表 (table) ，当前类型: {}",
-                ctx,
-                value.type_name()
-            )));
-        };
-
-        // 阶段一：提取原始别名映射 (Raw Extraction)
-        let mut raw_aliases: HashMap<String, Vec<OsString>> = HashMap::new();
-
-        for pair in table.pairs::<Value, Value>() {
-            let (raw_key, raw_val) = pair?;
-            let key = Self::parse_aliases_name(&raw_key)?;
-            let val = Self::parse_aliases_val(&ctx, &key, &raw_val)?;
-
-            raw_aliases.insert(key, val);
-        }
-        // 阶段二：递归拓扑打平与循环引用检测 (Flattening & Cycle Detection)
-        let mut visited_stack = HashSet::new();
-
-        for key in raw_aliases.keys() {
-            visited_stack.clear();
-            Self::detect_alias_cycle(key, &raw_aliases, &mut visited_stack)?;
-        }
-
-        // 阶段三：无环前提下的高效展开
-        let mut flattened_aliases: HashMap<String, Vec<OsString>> =
-            HashMap::with_capacity(raw_aliases.len());
-
-        let mut resolved_args = Vec::new();
-
-        for key in raw_aliases.keys() {
-            resolved_args.clear();
-            Self::expand_alias_dfs(key, &raw_aliases, &mut resolved_args);
-            flattened_aliases.insert(key.clone(), resolved_args.clone());
-        }
-
-        Ok(flattened_aliases)
-    }
-
-    /// 仅用于校验别名依赖图中是否存在死循环（不消耗额外的参数拼接内存）
-    fn detect_alias_cycle(
-        current_key: &str,
-        raw_aliases: &HashMap<String, Vec<OsString>>,
-        visited_stack: &mut HashSet<String>,
-    ) -> mlua::Result<()> {
-        // 递归栈中再次遇到相同的 Key，说明存在死循环
-        if visited_stack.contains(current_key) {
-            return Err(validation_error(format!(
-                "配置加载失败: 检测到别名循环嵌套依赖 'mr:{}'",
-                current_key
-            )));
-        }
-
-        if let Some(args) = raw_aliases.get(current_key) {
-            // 压栈
-            visited_stack.insert(current_key.to_string());
-
-            for arg in args {
-                let arg_str = arg.to_string_lossy();
-                if let Some(sub_key) = arg_str.strip_prefix("mr:") {
-                    // 如果引用的子别名在映射表中存在，则深度优先校验
-                    if raw_aliases.contains_key(sub_key) {
-                        Self::detect_alias_cycle(sub_key, raw_aliases, visited_stack)?;
-                    }
-                }
-            }
-
-            // 出栈（回溯）
-            visited_stack.remove(current_key);
-        }
-
-        Ok(())
-    }
-    /// 安全拓扑展开：在保证绝对无环的前提下递归展开 mr: 前缀参数
-    fn expand_alias_dfs(
-        current_key: &str,
-        raw_aliases: &HashMap<String, Vec<OsString>>,
-        out: &mut Vec<OsString>,
-    ) {
-        if let Some(args) = raw_aliases.get(current_key) {
-            for arg in args {
-                let arg_str = arg.to_string_lossy();
-                if let Some(sub_key) = arg_str.strip_prefix("mr:") {
-                    if raw_aliases.contains_key(sub_key) {
-                        // 安全地直接递归展开，无需再检查死循环
-                        Self::expand_alias_dfs(sub_key, raw_aliases, out);
-                    } else {
-                        // 找不到对应的别名，按原样参数输出
-                        out.push(arg.clone());
-                    }
-                } else {
-                    // 普通参数，直接输出
-                    out.push(arg.clone());
-                }
-            }
-        }
-    }
-}

 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::mirror::MirrorTarget;
+    use mirror_core::MirrorTarget;
    use mlua::{FromLua, Lua};

    fn parse(src: &str) -> mlua::Result<MirrorTarget> {