fix(config): 优化 lua 数据校验逻辑

- 新增 ValueValidator 优化结构化校验逻辑

.gitignore

@@ -1,3 +1,5 @@
 /target
 /.vscode
+/.idea
 *.exe
+./Cargo.lock

Cargo.lock

@@ -1,44 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "fs-err"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcd1163ae48bda72a20ae26d66a04d3094135cadab911cff418ae5e33f253431"
-
-[[package]]
-name = "rshim"
-version = "0.1.0"
-dependencies = [
- "fs-err",
- "unicode-bom",
- "winapi",
-]
-
-[[package]]
-name = "unicode-bom"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63ec69f541d875b783ca40184d655f2927c95f0bffd486faa83cd3ac3529ec32"
-
-[[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"

Cargo.toml

@@ -1,31 +1,32 @@
 [package]
 name = "rshim"
 version = "0.1.0"
-authors = ["anonymous <anonymous@example.com>"]
+edition = "2024"
-edition = "2018"
+rust-version = "1.94"
-
+license = "MIT OR Unlicense"
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+description = "A fast, safe Rust shim launcher for Scoop"
-
 
 [profile.release]
 opt-level = "z"
 panic = "abort"
-[dependencies]
-fs-err = "2.5.0"
-unicode-bom = "1"
 
-[dependencies.winapi]
+[dependencies]
-version = "0.3"
+anyhow = "1.0.104"
-features = [
+
-    "wincon",
+mlua = { version = "0.12.0", features = ["lua54", "vendored","send"] }
-    "consoleapi",
+windows-sys = { version = "0.61.2", features = [
-    "minwindef",
+    "Win32_Foundation",
-    "shellapi",
+    "Win32_System_Com",
-    "winuser",
+    "Win32_System_Console",
-    "synchapi",
+    "Win32_System_Registry",
-    "combaseapi",
+    "Win32_System_Threading",
-    "winbase",
+    "Win32_UI_Shell",
-    "processthreadsapi",
+    "Win32_UI_WindowsAndMessaging",
-    "objbase",
+] }
-    "impl-default"
+dunce = "1.0.5"
-]
+
+# 日志
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-appender = "0.2"
+encoding_rs = "0.8.35"

build.rs

@@ -0,0 +1,46 @@
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    // CARGO_MANIFEST_DIR -> 项目根目录路径
+    // CARGO_TARGET_DIR -> 用户自定义了 target 目录，使用该变量
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let target_dir = env::var("CARGO_TARGET_DIR")
+        .ok()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(&manifest_dir).join("target"));
+
+    // PROFILE -> 获取当前构建配置文件（debug/release）
+    let profile = env::var("PROFILE").unwrap();
+    // let output_dir = target_dir.join(&profile);
+
+    // 在 target/debug/ 或 target/release/ 下创建 bin2 目录
+    let output_dir = target_dir.join(&profile).join("bin2");
+
+    // cargo:rerun-if-changed -> 当指定文件变化时，重新运行 xxx
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=rshim.lua");
+    println!("cargo:rustc-env=OUTPUT_DIR={}", output_dir.display());
+
+    // 创建目录
+    let subdirs = ["bin", "tools"];
+    for subdir in &subdirs {
+        let path = output_dir.join(subdir);
+        if !path.exists() {
+            fs::create_dir_all(&path).expect(&format!("Failed to create {} directory", subdir));
+            println!("Created: {:?}", path);
+        }
+    }
+
+    // 复制文件
+    let source = PathBuf::from(&manifest_dir).join("mimic.lua");
+    let destination = output_dir.join("rshim.lua");
+
+    if source.exists() {
+        fs::copy(&source, &destination).expect("Failed to copy mimic.lua");
+        println!("Copied mimic.lua to: {:?}", destination);
+    } else {
+        panic!("mimic.lua not found at: {:?}", source);
+    }
+}

mimic.lua

@@ -0,0 +1,70 @@
+-- mimic.lua (总控制台)
+-- __SHIM_DIR__ 已经在 Rust 中注入完毕，并且是正斜杠格式 (例如 C:/Tools)
+local base_dir = __SHIM_DIR__
+
+-- 1. 自定义局部变量，方便复用与后续维护
+local python_home = base_dir .. "/tools/python39"
+
+return {
+    ---------------------------------------------------
+    -- 1. 标准相对路径 + 正斜杠拼接 (最推荐，绿色便携)
+    ---------------------------------------------------
+    ["numa"] = {
+        target = base_dir .. "/tools/numa/numa.exe",
+        -- 追加参数
+        args = { "--help" },
+        -- 注入环境变量，使用 get_env 获取宿主机当前值
+        env = {
+            PATH = { base_dir .. "/tools/numa", get_env("PATH") }
+        }
+    },
+    
+    ["git"] = {
+        target = base_dir .. "/git/bin/git.exe",
+        -- 追加参数
+        args = { "--no-pager" },
+        -- 注入环境变量，使用 get_env 获取宿主机当前值
+        env = {
+            PATH = { base_dir .. "/git/bin", get_env("PATH") }
+        }
+    },
+
+    ---------------------------------------------------
+    -- 2. Lua 原生字符串语法 [[ ]] (适合直接从 Windows 复制绝对路径)
+    ---------------------------------------------------
+    ["python"] = {
+        -- 在 [[]] 内部，\ 不需要写成 \\，直接粘贴即可
+        target = [[C:\Python310\python.exe]],
+        args = { "-B" },
+        -- 空字典也是合法的，等同于不设置
+        env = {
+            -- 普通字符串：Rust 直接新建/覆盖该环境变量
+            PYTHON_HOME = python_home,
+            HOME = base_dir .. "/home",
+
+            -- 数组列表：将 python_home 以及 python_home/Scripts 依次拼接到 PATH 前面
+            PATH = {
+                python_home,
+                python_home .. "/Scripts",
+                get_env("PATH")
+            }
+        }
+
+    },
+
+    ---------------------------------------------------
+    -- 3. 极简参数覆盖 (没有 args 和 env)
+    ---------------------------------------------------
+    ["curl"] = {
+        target = base_dir .. "/curl/curl.exe"
+    },
+
+    ---------------------------------------------------
+    -- 4. 模块化路由 (得益于 Rust 注入的 package.path)
+    -- require 能够直接在当前目录 或 tools/ 目录下寻找 node.lua
+    -- 模块缺失时由 Rust 侧记录日志并跳过该条目（见 runtime.rs）
+    ---------------------------------------------------
+    ["node"] = require("node"),
+
+    ["npm"] = require("npm")
+}

src/config.rs

@@ -0,0 +1,632 @@
+use mlua::{FromLua, Lua, LuaString, ObjectLike, Table, Value};
+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::fmt;
+use std::fmt::Display;
+use std::path::PathBuf;
+use std::process::Command;
+/// 构造一个带上下文的 FromLua 转换错误，便于定位配置问题
+fn conversion_error(message: impl Into<String>) -> mlua::Error {
+    mlua::Error::FromLuaConversionError {
+        from: "Lua value",
+        to: "ShimConfig".into(),
+        message: Some(message.into()),
+    }
+}
+
+/// 将 Lua 字符串转为 Rust 字符串；非 UTF-8 按系统默认的 ANSI/OEM (如 GBK) 进行安全解码
+fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {
+    let raw_bytes = &s.as_bytes().to_vec();
+    // 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));
+        }
+
+        // 非 UTF-8 时，按系统默认的 ANSI/OEM (如 GBK) 进行安全解码
+        let (cow, _, had_errors) = encoding_rs::GBK.decode(raw_bytes);
+        if had_errors {
+            return Err(mlua::Error::RuntimeError(
+                "路径包含无效/不支持的字节编码".into(),
+            ));
+        }
+        Ok(OsString::from(cow.as_ref()))
+    }
+}
+
+/// 按连续整数下标遍历表的序列部分；存在空洞或非序列键时返回错误，避免静默截断
+
+/// Lua 值校验器：针对不同上下文定义校验规则
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ValueValidator {
+    /// 目标程序路径：必须是字符串路径
+    Target,
+    /// 命令行参数元素：仅支持一维基础标量，禁止嵌套 Table
+    Args,
+    /// 环境变量值：支持基础标量及多维嵌套 Table（递归展平）
+    Env,
+}
+
+impl fmt::Display for ValueValidator {
+    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)"),
+        }
+    }
+}
+impl ValueValidator {
+    /// 【纯粹校验入口】只进行逻辑与结构判定，零副作用、不产生内存分配
+    pub fn validate(&self, value: &Value) -> mlua::Result<()> {
+        if matches!(self, Self::Target) {
+            println!("跟踪taget{}", value.type_name());
+        }
+        if matches!(self, Self::Args) {
+            println!("跟踪args2{}", value.type_name());
+        }
+        if matches!(self, Self::Env) {
+            println!("跟踪env{}", value.type_name());
+        }
+        match self {
+            Self::Target => match value {
+                Value::String(_) => Ok(()),
+                Value::Nil => Err(conversion_error("缺少必填字段 target（应为字符串路径）")),
+                other => Err(conversion_error(format!(
+                    "{} 需为有效的路径且类型必须是字符串，实际类型是 {}",
+                    self,
+                    other.type_name()
+                ))),
+            },
+            Self::Args => match value {
+                Value::Table(tbl) => self.validate_sequence_table(tbl),
+                other => Err(conversion_error(format!(
+                    "{} 必须是数组列表，实际类型是 {}",
+                    self,
+                    other.type_name()
+                ))),
+            },
+            Self::Env => match value {
+                Value::Nil
+                | Value::String(_)
+                | Value::Integer(_)
+                | Value::Number(_)
+                | Value::Boolean(_) => Ok(()),
+                Value::Table(tbl) => self.validate_sequence_table(tbl),
+                other => Err(conversion_error(format!(
+                    "{} 不支持 {} 类型, 仅支持 string/number/boolean 或嵌套数组",
+                    self,
+                    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;
+            }
+            match self {
+                Self::Args => match item {
+                    Value::Table(_) => {
+                        return Err(conversion_error(format!(
+                            "{} 仅支持一维数组，不能包含嵌套 Table,索引位置: {index}",
+                            self
+                        )));
+                    }
+                    Value::String(_)|Value::Integer(_)|Value::Number(_)|Value::Boolean(_) => {}
+                    _ => {return Err(conversion_error("args异常"))}
+                },
+                Self::Env => match item {
+                    Value::Table(_) => self.validate(&item)?,
+                    _ => {}
+                },
+                _ => {}
+            }
+
+            // // 元素规则判断
+            // match item {
+            //     // Args 规则拦截：禁止嵌套数组
+            //     Value::Table(_) if matches!(self, Self::Args) => {
+            //         return Err(conversion_error(format!(
+            //             "{} 仅支持一维数组，不能包含嵌套 Table,索引位置{index}",
+            //             self
+            //         )));
+            //     }
+            //     // 标量或合法嵌套表：调用 validate 递归深度判定
+            //     _ => self.validate(&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(conversion_error(format!(
+                        "{} 第 {} 个元素为 nil 或不存在（请检查漏写引号或变量未定义）",
+                        self, index
+                    )));
+                }
+                _ => {
+                    return Err(conversion_error(format!(
+                        "{} 必须是纯列表，不能包含键值对/字典结构",
+                        self
+                    )));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// 解析并校验 `target`
+    pub fn parse_target(value: &Value) -> mlua::Result<PathBuf> {
+        let validator = Self::Target;
+        validator.validate(&value)?;
+        let ctx = format!("{}", validator);
+
+        if let Value::String(s) = value {
+            let os_str = lua_string_2_os_string(&s)?;
+            Self::ensure_no_nul(&ctx, &os_str)?;
+            Ok(PathBuf::from(os_str))
+        } else {
+            unreachable!()
+        }
+    }
+    /// 解析并校验 `args`
+    pub fn parse_args(value: &Value) -> mlua::Result<Vec<OsString>> {
+        println!("跟踪args1{}", value.type_name());
+        let validator = Self::Args;
+        validator.validate(&value)?;
+        let ctx = format!("{}", validator);
+
+        let mut raw_parts = Vec::new();
+        collect_value_into(&ctx, value, &mut raw_parts)?;
+
+        for part in &raw_parts {
+            Self::ensure_no_nul(&ctx, &part)?;
+        }
+        Ok(raw_parts)
+    }
+    fn parse_env_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(conversion_error("环境变量名必须是合法的 UTF-8 字符串")),
+            },
+            other => {
+                return Err(conversion_error(format!(
+                    "环境变量键名类型错误：期望 string，实际是 {}",
+                    other.type_name()
+                )));
+            }
+        };
+        if name_str.is_empty() {
+            return Err(conversion_error("环境变量名不能为空"));
+        }
+        if name_str.contains('=') {
+            return Err(conversion_error(format!(
+                "环境变量名 [{}] 不能包含 '='",
+                name_str
+            )));
+        }
+        if name_str.contains('\0') {
+            return Err(conversion_error(format!(
+                "环境变量名 [{}] 不能包含 NUL 字符",
+                name_str
+            )));
+        }
+        Ok(name_str)
+    }
+
+    /// 解析、校验并拼接单个环境变量键值对 (`key`, `value`) -> (`String`, `OsString`)
+    fn parse_env_val(name: &str, raw_val: &Value) -> mlua::Result<OsString> {
+        Self::Env.validate(&raw_val)?;
+
+        let ctx = format!("环境变量 [{}]", name);
+        let mut parts = Vec::new();
+
+        collect_value_into(&ctx, 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| {
+            conversion_error(format!("{} 的值无法用系统路径分隔符拼接: {}", ctx, e))
+        })?;
+        Ok(joined_os_str)
+    }
+    /// 解析并校验单个环境变量键值对 (`key`, `val`) -> (`String`, `OsString`)
+    fn parse_env_pair(key: &Value, val: &Value) -> mlua::Result<(String, OsString)> {
+        // 1. 解析并校验 Key，拿到安全的 String
+        let name = Self::parse_env_name(key)?;
+        // 2. 借用 &name 传递给 Value 解析器作为上下文
+        let os_val = Self::parse_env_val(&name, val)?;
+        // 3. 所有权平滑转移，组装元组返回
+        Ok((name, os_val))
+    }
+    /// 解析整个 `env` Table，直接返回安全的环境变量 Map
+    pub fn parse_env(value: &Value) -> mlua::Result<HashMap<String, OsString>> {
+        let Value::Table(tbl) = value else {
+            // 这里作为防御性校验，外部虽然 match 过了，但内层仍保持强类型安全
+            return Err(conversion_error(format!(
+                "env 必须是键值表 (table)，实际类型是 {}",
+                value.type_name()
+            )));
+        };
+
+        let mut env_map = HashMap::new();
+
+        for pair in tbl.pairs::<Value, Value>() {
+            let (raw_key, raw_val) = pair?;
+            let (key, val) = Self::parse_env_pair(&raw_key, &raw_val)?;
+            env_map.insert(key, val);
+        }
+
+        Ok(env_map)
+    }
+    // ================= 3. 底层 NUL 字符跨平台安全检查 =================
+
+    fn ensure_no_nul(context_desc: &str, 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_desc
+                )));
+            }
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::ffi::OsStrExt;
+            if os_str.encode_wide().any(|c| c == 0) {
+                return Err(conversion_error(format!(
+                    "{} 的值不能包含 NUL 字符",
+                    context_desc
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// 【纯粹数据转换与展开】将已通过校验的 Value 递归解析为 OsString 动态数组
+pub fn collect_value_into(
+    context: &impl fmt::Display,
+    value: &Value,
+    out: &mut Vec<OsString>,
+) -> mlua::Result<()> {
+    match value {
+        Value::Nil => {}
+        Value::String(s) => out.push(lua_string_2_os_string(s)?),
+        Value::Integer(i) => out.push(OsString::from(i.to_string())),
+        Value::Number(n) => {
+            tracing::warn!(%context, value = %n, "浮点数将按十进制格式转换为字符串");
+            out.push(OsString::from(n.to_string()));
+        }
+        Value::Boolean(b) => {
+            tracing::warn!(%context, 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;
+                }
+                collect_value_into(context, &item, out)?;
+                index += 1;
+            }
+        }
+        _ => unreachable!("传入收集器的 Value 应已通过 validate 校验"),
+    }
+    Ok(())
+}
+
+/// 校验环境变量名的合法性（Windows 约束：非空、不含 '='、不含 NUL）
+// fn parse_env_name(name: &Value, val: &Value) -> mlua::Result<String> {
+//     let name_str = match name {
+//         Value::String(s) => s.to_str()?.to_string(),
+//
+//         _ => {
+//             return Err(conversion_error(format!(
+//                 "env 配置解析失败：(对应的值: {}, 类型: {}) 无效的键值！示例 HOME=\"/home\" 或 PATH = {{ \"C:/tools/\", \"D:/Windows\"}}）",
+//                 val.to_string()?,
+//                 val.type_name()
+//             )));
+//         }
+//     };
+//     if name_str.is_empty() {
+//         return Err(conversion_error("环境变量名不能为空"));
+//     }
+//     if name_str.contains('=') {
+//         return Err(conversion_error(format!(
+//             "环境变量名 [{}] 不能包含 '='",
+//             name_str
+//         )));
+//     }
+//     if name_str.contains('\0') {
+//         return Err(conversion_error(format!(
+//             "环境变量名 [{}] 不能包含 NUL 字符",
+//             name_str
+//         )));
+//     }
+//     Ok(name_str)
+// }
+
+/// 递归将任意 Lua Value 展开为扁平的字符串片段列表
+// fn collect_env_segments(value: Value, out: &mut Vec<OsString>) -> mlua::Result<()>{OK(())}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShimConfig {
+    pub target: PathBuf,
+    pub args: Vec<OsString>,
+    pub env: HashMap<String, OsString>,
+}
+
+impl ShimConfig {
+    /// 根据配置快速构建准备执行的 Command 对象
+    pub fn to_command<I, S>(&self, runtime_args: I) -> Command
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<std::ffi::OsStr>,
+    {
+        let mut cmd = Command::new(&self.target);
+
+        // 1. 先追加配置里固定的默认参数 (例如: node, --max-old-space-size=4096)
+        cmd.args(&self.args);
+
+        // 2. 透传外部动态运行时参数
+        cmd.args(runtime_args);
+
+        for (key, val) in &self.env {
+            // 直接应用环境变量（Lua 端已经处理好字符串拼接或列表合并）
+            cmd.env(key, val);
+        }
+
+        cmd
+    }
+}
+
+/// 实现 FromLua Trait，由 mlua 自动处理 Table 转换
+impl FromLua for ShimConfig {
+    fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
+        // 脚本返回必须是一个 Table 变体
+        let table = match value {
+            Value::Table(t) => t,
+            _ => {
+                return Err(conversion_error(format!(
+                    "期望得到一个 Lua Table 配置对象，实际是 {}",
+                    value.type_name()
+                )));
+            }
+        };
+
+        // 必填字段: target（严格限定为字符串，避免数字被 mlua 宽松转为字符串后掩盖错误）
+        let target = match table.get::<Option<Value>>("target")? {
+            None | Some(Value::Nil) => {
+                return Err(conversion_error("缺少必填字段 target（应为字符串路径）"));
+            }
+            Some(target_val) => ValueValidator::parse_target(&target_val)?,
+            // Value::String(s) => lua_string_2_os_string(&s)?,
+            // Value::Nil => {
+            //     return Err(conversion_error("缺少必填字段 target（应为字符串路径）"));
+            // }
+            // other => {
+            //     return Err(conversion_error(format!(
+            //         "target 需为有效的路径且类型必须是字符串，实际类型是 {}",
+            //         other.type_name()
+            //     )));
+            // }
+        };
+        // let mut args = Vec::new();
+
+        // 可选字段: args（缺失或 nil 时默认空列表；保留空字符串参数，与提权路径的 "" 语义一致）
+        let args = match table.get::<Option<Value>>("args")? {
+            None | Some(Value::Nil) => Vec::new(),
+            Some(args_val) => ValueValidator::parse_args(&args_val)?,
+        };
+
+        // 可选字段: env（只允许缺失/nil，其他类型由 Option<Table> 转换报错，不再静默忽略）
+        let env = match table.get::<Option<Value>>("env")? {
+            None | Some(Value::Nil) => HashMap::new(),
+            Some(ref env_val @ Value::Table(_)) => ValueValidator::parse_env(&env_val)?,
+            Some(other) => {
+                return Err(conversion_error(format!(
+                    "env 必须是键值表 (table)，实际类型是 {}",
+                    other.type_name()
+                )));
+            }
+        };
+        println!("环境变量结果：{:?}", env);
+        Ok(ShimConfig { target, args, env })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse(src: &str) -> mlua::Result<ShimConfig> {
+        let lua = Lua::new();
+        // 模拟 runtime 注入的 get_env：返回按平台分隔符拆分的段数组（空变量返回空表）
+        let get_env = lua
+            .create_function(|lua, key: String| -> mlua::Result<Table> {
+                let value = std::env::var(key).unwrap_or_default();
+                let segments: Vec<String> = if value.is_empty() {
+                    Vec::new()
+                } else {
+                    std::env::split_paths(std::ffi::OsStr::new(&value))
+                        .map(|p| p.to_string_lossy().into_owned())
+                        .collect()
+                };
+                lua.create_sequence_from(segments)
+            })
+            .unwrap();
+        lua.globals().set("get_env", get_env).unwrap();
+
+        let value = lua.load(src).eval::<Value>()?;
+        let t = ShimConfig::from_lua(value, &lua);
+        println!("读取出的数据：{:?}", t.clone()?);
+        t
+    }
+
+    #[test]
+    fn parses_basic_config() {
+        let cfg = parse(
+            r#"
+            return {
+                target = "C:/tools/git.exe",
+                args = { "--no-pager"},
+                env = {
+                    PATH = { "C:/tools/git/bin", "C:/Windows", get_env("PATH") },
+                    HOME = "C:/tools/home",
+                    CONST = 3,
+                    BOOL = true,
+
+                }
+            }
+            "#,
+        )
+        .unwrap();
+        assert_eq!(cfg.target, PathBuf::from("C:/tools/git.exe"));
+        assert_eq!(cfg.args, vec!["--no-pager"]);
+        assert_eq!(cfg.env.get("HOME").unwrap().to_str(), Some("C:/tools/home"));
+        // PATH 前缀来自配置，随后附加 get_env("PATH") 拆出的宿主 PATH 段
+        let path = cfg.env.get("PATH").unwrap().to_str().unwrap();
+        assert!(
+            path == "C:/tools/git/bin;C:/Windows"
+                || path.starts_with("C:/tools/git/bin;C:/Windows;"),
+            "unexpected PATH: {path}"
+        );
+    }
+
+    #[test]
+    fn missing_args_and_env_are_empty() {
+        let cfg = parse(r#"return { target = "t.exe" }"#).unwrap();
+        assert!(cfg.args.is_empty());
+        assert!(cfg.env.is_empty());
+    }
+
+    #[test]
+    fn keeps_empty_args() {
+        let cfg = parse(r#"return { target = "t.exe", args = { "" } }"#).unwrap();
+        assert_eq!(cfg.args, vec![""]);
+    }
+
+    #[test]
+    fn keeps_empty_env_value() {
+        let cfg = parse(r#"return { target = "t.exe", env = { FOO = "" } }"#).unwrap();
+        assert_eq!(cfg.env.get("FOO").unwrap().to_str(), Some(""));
+    }
+
+    #[test]
+    fn empty_array_clears_env_var() {
+        let cfg = parse(r#"return { target = "t.exe", env = { PATH = {} } }"#).unwrap();
+        assert_eq!(cfg.env.get("PATH").unwrap().to_str(), Some(""));
+    }
+
+    #[test]
+    fn expands_nested_env_array() {
+        // get_env("PATH") 现在返回拆分后的段数组，嵌套表应被递归展开
+        let cfg = parse(
+            r#"return { target = "t.exe", env = { PATH = { "C:/a", { "C:/b", "C:/c" } } } }"#,
+        )
+        .unwrap();
+        assert_eq!(
+            cfg.env.get("PATH").unwrap().to_str(),
+            Some("C:/a;C:/b;C:/c")
+        );
+    }
+
+    #[test]
+    fn rejects_wrong_env_type() {
+        assert!(parse(r#"return { target = "t.exe", env = "PATH=C:/x" }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_sparse_env_array() {
+        assert!(parse(r#"return { target = "t.exe", env = { P = { "a", nil, "b" } } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_mixed_key_env_array() {
+        assert!(parse(r#"return { target = "t.exe", env = { P = { a = "b" } } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_invalid_env_key() {
+        assert!(parse(r#"return { target = "t.exe", env = { ["FOO=1"] = "x" } }"#).is_err());
+        assert!(parse(r#"return { target = "t.exe", env = { [""] = "x" } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_nul_in_env_value() {
+        assert!(parse(r#"return { target = "t.exe", env = { P = { string.char(0) } } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_quote_in_env_value() {
+        // Windows 的 join_paths 对含双引号的路径元素返回错误
+        assert!(
+            parse(r#"return { target = "t.exe", env = { P = { string.char(34) } } }"#).is_err()
+        );
+    }
+
+    #[test]
+    fn rejects_unsupported_env_value_type() {
+        assert!(parse(r#"return { target = "t.exe", env = { F = function() end } }"#).is_err());
+    }
+
+    #[test]
+    fn missing_target_is_error() {
+        assert!(parse(r#"return { args = { "x" } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_non_string_target() {
+        assert!(parse(r#"return { target = 123 }"#).is_err());
+        assert!(parse(r#"return { target = false }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_non_string_args_element() {
+        // ValueShunt::Args 允许基础标量（数字/布尔）转字符串，仅禁止嵌套表
+        let cfg = parse(r#"return { target = "t.exe", args = { 1, true } }"#).unwrap();
+        assert_eq!(cfg.args, vec!["1", "true"]);
+    }
+
+    #[test]
+    fn rejects_sparse_args() {
+        assert!(parse(r#"return { target = "t.exe", args = { "a", nil, "b" } }"#).is_err());
+    }
+
+    #[test]
+    fn rejects_non_table_args() {
+        assert!(parse(r#"return { target = "t.exe", args = "-B" }"#).is_err());
+    }
+}

src/layout.rs

@@ -0,0 +1,67 @@
+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 tools_dir: PathBuf,
+    pub lua_file: PathBuf,
+}
+
+impl Layout {
+    /// 自动解析目录布局：
+    /// 1. 优先使用环境变量 RSHIM_HOME
+    /// 2. 兜底回退到当前垫片可执行文件所在目录推断 (exe -> bin -> root)
+    pub fn discover(current_exe: &Path) -> Result<Self> {
+        // 策略 1: 环境变量优先
+        if let Ok(home_val) = env::var("MIMIC_HOME") {
+            let trimmed = home_val.trim();
+            if !trimmed.is_empty() {
+                debug!(home = %trimmed, "检测到 MIMIC_HOME，采用环境变量配置");
+                return Self::from_base_dir(PathBuf::from(trimmed));
+            }
+        }
+
+        // 策略 2: 相对路径自动推断兜底
+        debug!("未配置 MIMIC_HOME，尝试从当前可执行文件路径推断根目录");
+        Self::from_executable(current_exe)
+    }
+
+    /// 基于确定的根目录构建完整布局
+    fn from_base_dir(base_dir: PathBuf) -> Result<Self> {
+        if !base_dir.is_dir() {
+            bail!("指定的根目录不存在或不是有效目录: [{}]", base_dir.display());
+        }
+
+        let bin_dir = base_dir.join("bin");
+        let tools_dir = base_dir.join("tools");
+        let lua_file = base_dir.join("mimic.lua");
+
+        Ok(Self {
+            base_dir,
+            bin_dir,
+            tools_dir,
+            lua_file,
+        })
+    }
+
+    /// 从当前可执行文件解析 shim 安装目录布局
+    fn from_executable(exe_path: &Path) -> 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)
+    }
+}

src/lib.rs

@@ -0,0 +1,11 @@
+mod config;
+mod layout;
+mod logger;
+mod runtime;
+mod shim;
+mod loader;
+
+pub use config::ShimConfig;
+pub use layout::Layout;
+pub use runtime::LuaRuntime;
+pub use shim::Shim;

src/logger.rs

@@ -0,0 +1,39 @@
+use std::path::Path;
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::{EnvFilter, fmt};
+
+/// 初始化日志系统，返回的 `_guard` 必须在 main 作用域内保持存活直到程序退出
+pub fn init_file_logger(log_dir: impl AsRef<Path>) -> Option<WorkerGuard> {
+    // 允许通过环境变量动态控制日志级别，如 SHIM_LOG=debug，默认 debug 或 info
+    let filter = EnvFilter::try_from_env("SHIM_LOG").unwrap_or_else(|_| EnvFilter::new("debug"));
+
+    // 1. 创建按天滚动的日志追加器 (每天生成类似 shim.2026-08-14.log)
+    let file_appender = tracing_appender::rolling::daily(log_dir, "shim.log");
+
+    // 2. 包装为非阻塞后台写入（不会拖慢主程序的启动与执行速度）
+    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+
+    // 3. 构建 Subscriber，只输出到文件，不输出到控制台
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_writer(non_blocking) // 写入文件
+        .with_ansi(false) // 关闭终端彩色转义字符
+        .with_target(false) // 隐藏模块前缀（可选）
+        .init();
+
+    Some(guard)
+}
+
+// 调用
+// fn main() -> Result<(), Box<dyn std::error::Error>> {
+//     // 假设日志存放在安装根目录下的 logs 文件夹
+//     // 也可以先快速推导 layout 拿到 log_dir
+//     let log_dir = "path/to/root_dir/logs";
+//     let _guard = init_file_logger(log_dir);
+//
+//     // 此处写你的 Shim 业务逻辑
+//     // 业务代码中所有的 debug!/info!/warn! 都会静默写入文件，控制台干干净净
+//     let config = Shim::load()?;
+//
+//     Ok(())
+// }

src/main.rs

@@ -1,44 +1,48 @@
-use std::{
+use rshim::Shim;
-    env,
+use std::os::windows::ffi::OsStrExt;
-    ffi::CString,
+use std::{env, ffi::CString, mem::size_of, path::Path, process::exit, ptr::null_mut};
-    mem::size_of,
+use tracing_subscriber::{EnvFilter, fmt};
-    path::Path,
-    process::{exit, Command},
-    ptr::null_mut,
-};
 
-use winapi::{
+use std::ffi::{OsStr, OsString};
-    shared::minwindef::{BOOL, DWORD, FALSE, TRUE},
+
-    um::{
+use windows_sys::Win32::UI::Shell::{SHELLEXECUTEINFOW, ShellExecuteExW};
-        combaseapi::CoInitializeEx,
+
-        consoleapi,
+use windows_sys::Win32::Foundation::CloseHandle;
-        objbase::{COINIT_APARTMENTTHREADED, COINIT_DISABLE_OLE1DDE},
+use windows_sys::{
-        processthreadsapi::GetExitCodeProcess,
+    Win32::{
-        shellapi::{ShellExecuteExA, SEE_MASK_NOASYNC, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOA},
+        Foundation::{FALSE, TRUE},
-        synchapi::WaitForSingleObject,
+        System::{
-        winbase::INFINITE,
+            Com::{COINIT_APARTMENTTHREADED, COINIT_DISABLE_OLE1DDE, CoInitializeEx},
-        wincon,
+            Console::{
-        winuser::SW_NORMAL,
+                CTRL_BREAK_EVENT, CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT,
+                CTRL_SHUTDOWN_EVENT, SetConsoleCtrlHandler,
             },
+            Threading::{GetExitCodeProcess, INFINITE, WaitForSingleObject},
+        },
+        UI::{
+            Shell::{
+                SEE_MASK_NOASYNC, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOA, ShellExecuteExA,
+            },
+            WindowsAndMessaging::SW_NORMAL,
+        },
+    },
+    core::BOOL,
 };
 
-unsafe extern "system" fn routine_handler(evt: DWORD) -> BOOL {
+unsafe extern "system" fn console_ctrl_handler(evt: u32) -> BOOL {
     match evt {
-        wincon::CTRL_C_EVENT => TRUE,        //eprintln!("ctrl_c handled!"),
+        CTRL_C_EVENT => TRUE,        //eprintln!("ctrl_c handled!"),
-        wincon::CTRL_BREAK_EVENT => TRUE,    //eprintln!("ctrl_break handled!"),
+        CTRL_BREAK_EVENT => TRUE,    //eprintln!("ctrl_break handled!"),
-        wincon::CTRL_CLOSE_EVENT => TRUE,    //eprintln!("ctrl_close handled!"),
+        CTRL_CLOSE_EVENT => TRUE,    //eprintln!("ctrl_close handled!"),
-        wincon::CTRL_LOGOFF_EVENT => TRUE,   //eprintln!("ctrl_logoff handled!"),
+        CTRL_LOGOFF_EVENT => TRUE,   //eprintln!("ctrl_logoff handled!"),
-        wincon::CTRL_SHUTDOWN_EVENT => TRUE, //eprintln!("ctrl_shutdown handled!"),
+        CTRL_SHUTDOWN_EVENT => TRUE, //eprintln!("ctrl_shutdown handled!"),
         other => {
-            eprintln!("unknown event number: {}, unhandled!", other);
+            eprintln!("未知的系统事件编号: {}，未处理！", other);
-            return FALSE;
+            FALSE
         }
     }
 }
 
-mod shims;
-use shims::Shim;
-
 const EXIT_FAILED_LOAD_SHIM: i32 = 1;
 const EXIT_FAILED_SPAWN_PROG: i32 = 2;
 const EXIT_FAILED_WAIT_PROG: i32 = 3;
@@ -46,45 +50,55 @@ const EXIT_PROG_TERMINATED: i32 = 4;
 
 const ERROR_ELEVATION_REQUIRED: i32 = 740;
 fn main() {
-    let res: BOOL = unsafe { consoleapi::SetConsoleCtrlHandler(Some(routine_handler), TRUE) };
+    // 初始化日志：输出到 stderr，避免污染 shim 子进程的 stdout
+    fmt()
+        .with_writer(std::io::stderr)
+        .with_env_filter(
+            EnvFilter::try_from_env("SHIM_LOG").unwrap_or_else(|_| EnvFilter::new("warn")),
+        )
+        .init();
+
+    let res: BOOL = unsafe { SetConsoleCtrlHandler(Some(console_ctrl_handler), TRUE) };
     if res == FALSE {
-        eprintln!("shim: register Ctrl handler failed.");
+        eprintln!("警告: 注册控制台中断事件处理器失败。");
     }
 
-    let calling_args: Vec<_> = env::args().skip(1).collect();
+    let calling_args: Vec<_> = env::args_os().skip(1).collect();
-    let shim = match Shim::init() {
+    let shim = match Shim::load() {
         Ok(v) => v,
         Err(e) => {
-            eprintln!("Error while loading shim: {}", e);
+            eprintln!("加载代理(shim)配置时发生错误: {}", e);
             exit(EXIT_FAILED_LOAD_SHIM);
         }
     };
-    let args = if let Some(mut shim_args) = shim.args {
+
-        shim_args.extend_from_slice(calling_args.as_slice());
+    // 构建 Command：复用 ShimConfig::to_command（含 args/env 注入），避免重复逻辑
-        shim_args
+    let mut cmd = shim.to_command(&calling_args);
-    } else {
+
-        calling_args
+    // 提权回退时需要完整参数：配置默认参数 + 调用方透传参数
-    };
+    let mut args = shim.args.clone();
-    let mut cmd = match Command::new(&shim.target_path).args(&args).spawn() {
+    args.extend_from_slice(&calling_args);
+
+    let mut child = match cmd.spawn() {
         Ok(v) => v,
         Err(e) if e.raw_os_error() == Some(ERROR_ELEVATION_REQUIRED) => {
-            exit(execute_elevated(&shim.target_path, &args))
+            exit(execute_elevated(&shim.target, &args, Some(&shim.env)))
         }
         Err(e) => {
             eprintln!(
-                "Error while spawning target program `{}`: {}",
+                "启动目标程序 [{}] 时发生错误: {}",
-                shim.target_path.to_string_lossy(),
+                shim.target.to_string_lossy(),
                 e
             );
             exit(EXIT_FAILED_SPAWN_PROG);
         }
     };
-    let status = match cmd.wait() {
+    let status = match child.wait() {
         Ok(v) => v,
         Err(e) => {
             eprintln!(
-                "Error while waiting target program `{}`: {}",
+                "等待目标程序 [{}] 执行完毕时发生错误: {}",
-                shim.target_path.to_string_lossy(),
+                shim.target.to_string_lossy(),
                 e
             );
             exit(EXIT_FAILED_WAIT_PROG);
@@ -92,54 +106,130 @@ fn main() {
     };
     exit(status.code().unwrap_or(EXIT_PROG_TERMINATED))
 }
+// 辅助函数：将任意 OsStr 转换为以 \0 结尾的 UTF-16 宽字符向量 (Vec<u16>)
+fn to_wide_null(s: impl AsRef<OsStr>) -> Vec<u16> {
+    s.as_ref().encode_wide().chain(std::iter::once(0)).collect()
+}
 
-fn execute_elevated(program: &Path, args: &[String]) -> i32 {
+fn execute_elevated(
-    let runas = CString::new("runas").unwrap();
+    program: &Path,
-    let program = CString::new(program.to_str().unwrap()).unwrap();
+    args: &[OsString],
-    let mut params = String::new();
+    env_vars: Option<&std::collections::HashMap<String, OsString>>,
-    for arg in args.iter() {
+) -> i32 {
-        params.push(' ');
+    // 若提权启动，在此处将环境变量设置给当前进程（即将弹窗 UAC 的进程，随后会被子进程继承）
-        if arg.len() == 0 {
+    if let Some(env_map) = env_vars {
-            params.push_str("\"\"");
+        for (k, v) in env_map {
-        } else if arg.find(&[' ', '\t', '"'][..]).is_none() {
+            unsafe {
-            params.push_str(&arg);
+                env::set_var(k, v);
+            }
+        }
+    }
+    // 2. 将参数列表按 Windows 命令行规则拼装为单个命令行字符串
+    let mut arguments_os = OsString::new();
+    for (i, arg) in args.iter().enumerate() {
+        if i > 0 {
+            arguments_os.push(" ");
+        }
+        let arg_str = arg.to_string_lossy();
+        if arg_str.is_empty() {
+            arguments_os.push("\"\"");
+        } else if !arg_str.contains([' ', '\t', '"']) {
+            arguments_os.push(arg);
         } else {
-            params.push('"');
+            // 包含空格或引号时进行标准转义包裹
-            for c in arg.chars() {
+            arguments_os.push("\"");
+            for c in arg_str.chars() {
                 match c {
-                    '\\' => params.push_str("\\\\"),
+                    '\\' => arguments_os.push("\\\\"),
-                    '"' => params.push_str("\\\""),
+                    '"' => arguments_os.push("\\\""),
-                    c => params.push(c),
+                    _ => arguments_os.push(c.to_string()),
                 }
             }
-            params.push('"');
+            arguments_os.push("\"");
         }
     }
+    // let runas = CString::new("runas").unwrap();
+    // let program = CString::new(program.to_str().unwrap()).unwrap();
+    // let mut arguments = String::new();
+    // for arg in args.iter() {
+    //     arguments.push(' ');
+    //     if arg.len() == 0 {
+    //         arguments.push_str("\"\"");
+    //     } else if arg.find(&[' ', '\t', '"'][..]).is_none() {
+    //         arguments.push_str(&arg);
+    //     } else {
+    //         arguments.push('"');
+    //         for c in arg.chars() {
+    //             match c {
+    //                 '\\' => arguments.push_str("\\\\"),
+    //                 '"' => arguments.push_str("\\\""),
+    //                 c => arguments.push(c),
+    //             }
+    //         }
+    //         arguments.push('"');
+    //     }
+    // }
+    // 3. 准备 Windows 宽字符参数
+    let runas = to_wide_null("runas");
+    let program_wide = to_wide_null(program.as_os_str());
+    let arguments_wide = to_wide_null(&arguments_os);
 
-    let params = CString::new(&params[..]).unwrap();
+    let mut info = SHELLEXECUTEINFOW {
-    let mut info = SHELLEXECUTEINFOA::default();
+        cbSize: size_of::<SHELLEXECUTEINFOW>() as u32,
-    info.cbSize = size_of::<SHELLEXECUTEINFOA>() as DWORD;
+        fMask: SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS,
-    info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS;
+        hwnd: null_mut(),
-    info.lpVerb = runas.as_ptr();
+        lpVerb: runas.as_ptr(),
-    info.lpFile = program.as_ptr();
+        lpFile: program_wide.as_ptr(),
-    info.lpParameters = params.as_ptr();
+        lpParameters: arguments_wide.as_ptr(),
-    info.nShow = SW_NORMAL;
+        lpDirectory: null_mut(),
+        nShow: SW_NORMAL as i32,
+        hInstApp: null_mut(),
+        lpIDList: null_mut(),
+        lpClass: null_mut(),
+        hkeyClass: null_mut(),
+        dwHotKey: 0,
+        Anonymous: unsafe { std::mem::zeroed() },
+        hProcess: null_mut(),
+    };
+    // let arguments = CString::new(&arguments[..]).unwrap();
+    // let mut info = SHELLEXECUTEINFOA::default();
+    // info.cbSize = size_of::<SHELLEXECUTEINFOA>() as u32;
+    // info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS;
+    // info.lpVerb = runas.as_ptr().cast::<u8>();
+    // info.lpFile = program.as_ptr().cast::<u8>();
+    // info.lpParameters = arguments.as_ptr().cast::<u8>();
+    // info.nShow = SW_NORMAL;
     let res = unsafe {
         CoInitializeEx(
             null_mut(),
-            COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE,
+            (COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE) as u32,
         );
-        ShellExecuteExA(&mut info as *mut _)
+        // ShellExecuteExA(&mut info as *mut _)
+        ShellExecuteExW(&mut info)
     };
     if res == FALSE || info.hProcess == null_mut() {
         return EXIT_FAILED_SPAWN_PROG;
     }
-    let mut code: DWORD = 0;
+    // 5. 等待提权子进程执行结束并获取退出状态码
+    let mut exit_code: u32 = 0;
     unsafe {
         WaitForSingleObject(info.hProcess, INFINITE);
-        if GetExitCodeProcess(info.hProcess, &mut code as *mut _) == FALSE {
+        let ok = GetExitCodeProcess(info.hProcess, &mut exit_code);
+        CloseHandle(info.hProcess); // 释放进程句柄，防止资源泄露
+
+        if ok == FALSE {
             return EXIT_FAILED_WAIT_PROG;
         }
     }
-    return code as i32;
+
+    exit_code as i32
+
+    // let mut code: u32 = 0;
+    // unsafe {
+    //     WaitForSingleObject(info.hProcess, INFINITE);
+    //     if GetExitCodeProcess(info.hProcess, &mut code as *mut _) == FALSE {
+    //         return EXIT_FAILED_WAIT_PROG;
+    //     }
+    // }
+    // code as i32
 }

src/runtime.rs

@@ -0,0 +1,280 @@
+use crate::{ShimConfig, Layout};
+use anyhow::{Context, Result, anyhow, bail};
+use mlua::{FromLua, Lua, StdLib, Table, Value};
+use std::ffi::OsStr;
+use std::path::Path;
+use std::{env, fs};
+/// 将 Path 转换为适合 Lua 使用的安全字符串路径
+fn normalize_path_for_lua(path: &Path) -> String {
+    // 自动将 Windows UNC 规范路径转回传统路径
+    let simplified = dunce::simplified(path);
+    simplified.to_string_lossy().replace('\\', "/")
+}
+
+pub struct LuaRuntime {
+    lua: Lua,
+}
+
+impl LuaRuntime {
+    /// 初始化限定权限的 Lua 沙箱环境
+    pub fn new(layout: &Layout) -> Result<Self> {
+        // 只加载安全的标准库，剥离 os / io 等风险模块
+        let lua = Lua::new_with(
+            StdLib::TABLE | StdLib::STRING | StdLib::MATH | StdLib::PACKAGE,
+            mlua::LuaOptions::default(),
+        )
+        .context("初始化 Lua 失败")?;
+
+        let globals = lua.globals();
+
+        // 统一使用 POSIX 风格路径规范化路径字符串
+        let base_dir = normalize_path_for_lua(&layout.base_dir);
+        let tools_dir = normalize_path_for_lua(&layout.tools_dir);
+
+        // 1. 注入锚点变量 __SHIM_DIR__（shim 安装根目录）
+        globals
+            .set("__SHIM_DIR__", base_dir.clone())
+            .context("设置 __SHIM_DIR__ 环境变量失败")?;
+
+        // 2. 安全暴露 get_env 供配置读取环境变量
+        //    返回按平台路径分隔符拆分后的段数组（自动剥离引号包裹），
+        //    便于 PATH 等列表变量直接嵌入数组：PATH = { prefix, get_env("PATH") }
+        let get_env = lua
+            .create_function(|lua, key: String| -> mlua::Result<Table> {
+                // 缺失变量视为空字符串，拆分后得到空表（不贡献任何路径段）
+                let value = env::var_os(key).unwrap_or_default();
+                // 空输入返回空表；否则按平台分隔符拆分（split_paths 会剥离引号包裹）
+                if value.is_empty() {
+                    return lua.create_table();
+                }
+                let table = lua.create_table()?;
+                for (i, p) in env::split_paths(&value).enumerate() {
+                    // 3. 跨平台提取原始字节并转为 LuaString，保证 100% 无损
+                    #[cfg(unix)]
+                    let lua_str = {
+                        use std::os::unix::ffi::OsStrExt;
+                        lua.create_string(p.as_os_str().as_bytes())?
+                    };
+
+                    #[cfg(windows)]
+                    let lua_str = {
+                        // Windows 路径是 UTF-16，转成字符串或保持其字节表达
+                        let s = p.to_string_lossy();
+                        lua.create_string(s.as_bytes())?
+                    };
+
+                    table.set(i + 1, lua_str)?;
+                }
+
+                Ok(table)
+            })
+            .context("注册 get_env 函数失败")?;
+
+        globals
+            .set("get_env", get_env)
+            .context("挂载 get_env 全局函数失败")?;
+
+        // 3. 配置 package.path，确保 require 行为正常
+        if let Ok(package) = globals.get::<Table>("package") {
+            let _ = package.set("cpath", "");
+            let _ = package.set("loadlib", Value::Nil);
+
+            if let Ok(path) = package.get::<String>("path") {
+                let new_path = format!(
+                    "{};{}/?.lua;{}/?/init.lua;{}/?.lua;{}/?/init.lua",
+                    path, base_dir, base_dir, tools_dir, tools_dir
+                );
+                let _ = package.set("path", new_path);
+            }
+        }
+
+        // 4. 包装 require：配置模块缺失/加载失败时记录日志并跳过该条目，
+        //    而不是让整个 mimic.lua 解析失败（排查问题时日志可见）
+        let original_require: mlua::Function = globals
+            .get("require")
+            .context("获取内置 require 函数失败")?;
+        globals
+            .set("_rshim_original_require", &original_require)
+            .context("备份原始 require 函数失败")?;
+
+        let wrapped_require = lua
+            .create_function(|lua, module: String| -> mlua::Result<Value> {
+                let original: mlua::Function = lua.globals().get("_rshim_original_require")?;
+                match original.call::<Value>(module.clone()) {
+                    Ok(value) => Ok(value),
+                    Err(e) => {
+                        tracing::warn!(
+                            module = %module,
+                            error = %e,
+                            "配置模块加载失败，已跳过该条目（可在独立配置文件中定义）"
+                        );
+                        Ok(Value::Nil)
+                    }
+                }
+            })
+            .context("创建包装版 require 函数失败")?;
+
+        globals
+            .set("require", wrapped_require)
+            .context("重载 require 函数失败")?;
+
+        Ok(Self { lua })
+    }
+
+    /// 执行指定脚本文件，直接返回完整的 Lua Table
+    pub fn eval_script<T: FromLua>(&self, path: impl AsRef<Path>) -> Result<T> {
+        let path = path.as_ref();
+        // println!("path {:?}", path);
+        let bytes =
+            fs::read(path).with_context(|| format!("无法读取配置文件: {}", path.display()))?;
+
+        let code = String::from_utf8(bytes).with_context(|| {
+            format!(
+                "{} 不是有效的 UTF-8 文件（请将 Lua 配置文件保存为 UTF-8 编码）",
+                path.display()
+            )
+        })?;
+        println!("code {:?}", code);
+        let chunk_name = format!("@{}", path.display());
+
+        self.lua
+            .load(&code)
+            .set_name(&chunk_name)
+            .eval::<T>()
+            // .map_err(|e| anyhow!(e.to_string()))
+            .with_context(|| format!("执行 Lua 配置文件失败: {}", path.display()))
+    }
+
+}
+
+#[cfg(test)]
+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"),
+            tools_dir: root.join("tools"),
+            lua_file: Default::default(),
+        }
+    }
+
+    #[test]
+    fn missing_module_require_returns_nil() {
+        let runtime = LuaRuntime::new(&test_layout()).unwrap();
+        let value: Value = runtime
+            .lua
+            .load(r#"return require("rshim_test_no_such_module")"#)
+            .eval()
+            .unwrap();
+        assert!(matches!(value, Value::Nil));
+    }
+
+    #[test]
+    fn builtin_module_require_still_works() {
+        let runtime = LuaRuntime::new(&test_layout()).unwrap();
+        let value: Value = runtime
+            .lua
+            .load(r#"return pcall(require, "string")"#)
+            .eval()
+            .unwrap();
+        assert!(matches!(value, Value::Boolean(true)));
+    }
+
+    #[test]
+    fn get_env_returns_split_table() {
+        let runtime = LuaRuntime::new(&test_layout()).unwrap();
+        let value: Value = runtime
+            .lua
+            .load(r#"return get_env("PATH")"#)
+            .eval()
+            .unwrap();
+        let table = match value {
+            Value::Table(t) => t,
+            other => panic!("expected table, got {}", other.type_name()),
+        };
+        assert!(
+            table.raw_len() >= 1,
+            "PATH should have at least one segment"
+        );
+
+        // split_paths 会剥离引号包裹，拆分段不应再含双引号
+        for i in 1..=table.raw_len() {
+            let seg: String = table.raw_get(i).unwrap();
+            assert!(
+                !seg.contains('"'),
+                "segment should not contain quote: {seg:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn get_env_missing_returns_empty_table() {
+        let runtime = LuaRuntime::new(&test_layout()).unwrap();
+        let value: Value = runtime
+            .lua
+            .load(r#"return get_env("RSHIM_TEST_NO_SUCH_VAR_12345")"#)
+            .eval()
+            .unwrap();
+        match value {
+            Value::Table(t) => assert_eq!(t.raw_len(), 0),
+            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: ShimConfig = 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"
+            );
+        }
+    }
+}

src/shim.rs

@@ -0,0 +1,101 @@
+use crate::{LuaRuntime, ShimConfig, Layout};
+use anyhow::{Context, Result, bail};
+use mlua::{Table, Value};
+use std::env;
+use tracing::{debug, trace, warn};
+pub struct Shim;
+
+impl Shim {
+    pub fn load() -> Result<ShimConfig> {
+        let current_exe = env::current_exe().context("获取代理程序路径失败: {}")?;
+        debug!("当前目录 {}", current_exe.display());
+
+        let target_name = current_exe
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .with_context(|| format!("无法从路径 [{}] 提取有效的程序名称", current_exe.display()))?
+            .to_lowercase();
+        debug!(
+            target_name = %target_name,
+            current_exe = %current_exe.display(),
+            "开始加载 Shim 配置"
+        );
+        let layout = Layout::discover(&current_exe)?;
+
+        debug!(
+            root_dir = %layout.base_dir.display(),
+            bin_dir = %layout.bin_dir.display(),
+            tools_dir = %layout.tools_dir.display(),
+            "Shim 目录布局解析完成"
+        );
+
+        let runtime = LuaRuntime::new(&layout)?;
+
+        Self::resolve_config(&runtime, &layout, &target_name)
+    }
+
+    fn resolve_config(
+        runtime: &LuaRuntime,
+        paths: &Layout,
+        target_name: &str,
+    ) -> Result<ShimConfig> {
+        // 策略 1: 尝试加载全局配置文件 mimic.lua
+        let global_config = paths.base_dir.join("rshim.lua");
+
+        // if !global_config.is_file() {
+        //     bail!(
+        //         "未找到主配置文件: [{}]，请确保在安装根目录创建 rshim.lua",
+        //         global_config.display()
+        //     );
+        // }
+
+
+        if global_config.is_file() {
+            trace!(path = %global_config.display(), "发现全局配置文件，尝试解析");
+            let root_table: Table = runtime.eval_script(&global_config)?;
+
+            // 检查 mimic.lua 中是否存在以 target_name 命名的 Table 节点
+            if root_table
+                .contains_key(target_name)
+                .context("检查全局配置失败")?
+            {
+                let target_val: ShimConfig = root_table
+                    .get(target_name)
+                    .with_context(|| format!("解析配置 [{}] 失败: ", target_name))?;
+                debug!(
+                    target = %target_name,
+                    source = %global_config.display(),
+                    "成功从全局配置文件中匹配到目标工具"
+                );
+
+                return Ok(target_val);
+            }
+            // 穿透：若全局配置文件存在但未包含当前程序的 key，继续向下探查
+            trace!(target = %target_name, "全局配置文件中未包含该目标，继续探查独立配置");
+        }
+
+        // 策略 2: 降级寻找独立文件 ({exe}.lua)，优先顺序：tools/ > root/
+        let target_filename = format!("{}.lua", target_name);
+        let candidates = [
+            paths.tools_dir.join(&target_filename),
+            paths.base_dir.join(&target_filename),
+        ];
+
+        for config_path in &candidates {
+            if config_path.is_file() {
+                debug!(path = %config_path.display(), "找到独立配置文件，开始加载");
+                // 直接泛型反序列化为 ShimConfig
+                return runtime.eval_script::<ShimConfig>(config_path);
+            }
+            trace!(path = %config_path.display(), "独立配置文件不存在，跳过");
+        }
+
+        // 策略 3: 所有查找失败，抛出错误
+        warn!(target = %target_name, "未找到任何匹配的配置文件");
+        bail!(
+            "未找到关于 '{}' 的配置。请检查 mimic.lua 或特定的 {}.lua 文件",
+            target_name,
+            target_name
+        );
+    }
+}

src/shims.rs

@@ -1,89 +0,0 @@
-use fs_err as fs;
-use std::{
-    collections::HashMap,
-    env,
-    io::{Error, ErrorKind},
-    path::{Path, PathBuf},
-};
-pub struct Shim {
-    pub target_path: PathBuf,
-    pub args: Option<Vec<String>>,
-}
-
-impl Shim {
-    pub fn init() -> Result<Self, Error> {
-        let shim_path = get_shim_file_path()?;
-        let kvs = parse_shim_file(&shim_path)?;
-        let target_path = match kvs.get("path") {
-            Some(p) => PathBuf::from(p),
-            None => {
-                return Err(Error::new(
-                    ErrorKind::NotFound,
-                    format!("no path key in {}", shim_path.to_string_lossy()),
-                ))
-            }
-        };
-        let args = kvs.get("args").map(|a| {
-            a.split_whitespace()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        });
-        Ok(Self { target_path, args })
-    }
-}
-
-fn get_shim_file_path() -> Result<PathBuf, Error> {
-    let mut current_exe = env::current_exe().map_err(|e| {
-        Error::new(
-            ErrorKind::Other,
-            format!("acquiring shim executable path: {}", e),
-        )
-    })?;
-    if !current_exe.set_extension("shim") {
-        return Err(Error::new(
-            ErrorKind::Other,
-            format!("{} is not a file", current_exe.to_string_lossy()),
-        ));
-    }
-    Ok(current_exe)
-}
-use unicode_bom::Bom;
-fn parse_shim_file(shim_path: &Path) -> Result<HashMap<String, String>, Error> {
-    let mut kvs = HashMap::new();
-
-    let raw_content = fs::read_to_string(shim_path).map_err(|e| {
-        Error::new(
-            ErrorKind::Other,
-            format!("reading {}: {}", shim_path.to_string_lossy(), e),
-        )
-    })?;
-    //NOTE: expedient trick for utf-8 with bom
-    let bom = Bom::from(raw_content.as_bytes());
-    for line in raw_content[bom.len()..]
-        .lines()
-        .filter(|l| !l.trim().is_empty())
-    {
-        let mut components = line.split("=");
-        let key = match components.next() {
-            Some(k) => k.trim(),
-            None => {
-                return Err(Error::new(
-                    ErrorKind::InvalidData,
-                    format!("invalid line in shim file: {}", line),
-                ));
-            }
-        };
-        let value = match components.next() {
-            Some(v) => v.trim(),
-            None => {
-                return Err(Error::new(
-                    ErrorKind::InvalidData,
-                    format!("invalid line in shim file: {}", line),
-                ));
-            }
-        };
-        kvs.insert(key.to_string(), value.to_string());
-    }
-
-    Ok(kvs)
-}