chore: bump version to v0.1.53 for mcp-stdio-proxy and update environment handling in server builders

Author: dongdada29

CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.1.52] - 2026-02-15
+
+### Fixed
+
+- **PATH 按段去重**: `ensure_runtime_path` 从整段 `starts_with` 改为按分隔符拆段去重，
+  解决上层多次前置导致的 `node/bin` 重复条目问题
+- **config PATH 覆盖**: 用户在 MCP config env 中指定自定义 PATH 时，
+  仍然确保应用内置运行时路径（`NUWAX_APP_RUNTIME_PATH`）在最前面
+- **env value 泄露**: `log_command_details` 不再打印 env 变量的 value，
+  仅输出 key 列表，避免泄露敏感信息（如 token、secret）
+
+### Added
+
+- **`mcp-common::diagnostic` 模块**: 提取子进程启动诊断日志为独立模块，
+  提供 `log_stdio_spawn_context`、`format_spawn_error`、`format_path_summary` 等公共函数，
+  减少业务代码中的日志侵入
+- **启动阶段环境诊断**: `env_init` 结束后输出 PATH 摘要和镜像环境变量最终值
+- **spawn 失败上下文**: SSE/Stream 子进程 spawn 失败时输出完整错误上下文
+  （command、args、PATH），便于快速定位可执行文件找不到的问题
+- **build 失败上下文**: `mcp_start_task` 中 SSE/Stream server build 失败时
+  通过 `anyhow::Context` 附加 MCP ID 和服务类型
+- **`ensure_runtime_path` 单元测试**: 新增 5 个测试覆盖前置、部分去重、
+  全部已存在、双重重复等场景
+
+### Changed
+
+- **server_builder PATH 逻辑简化**: 两侧 `connect_stdio` 从三分支
+  （继承/config/缺失）统一为：取基础 PATH → `ensure_runtime_path` → 传递给子进程
+- **无镜像提示**: 未配置镜像源时输出提示行，而非静默跳过
+
+## [0.1.51] - 2026-02-14
+
+### Changed
+
+- 版本号更新
+
+## [0.1.49] - 2026-02-13
+
+### Added
+
+- **镜像源配置**: 支持通过 `config.yml` 配置 npm/PyPI 镜像源，
+  环境变量优先级高于配置文件
+- **环境变量初始化**: `env_init` 模块统一管理子进程环境（镜像源 + 内置运行时 PATH）
+- **`UV_INSECURE_HOST` 支持**: HTTP 类型的 PyPI 镜像自动提取 host 并设置
+
+## [0.1.48] - 2026-02-12
+
+### Added
+
+- **跨平台进程管理**: `process_compat` 模块提供 `wrap_process_v8` / `wrap_process_v9` 宏，
+  统一 Unix（ProcessGroup）和 Windows（JobObject + CREATE_NO_WINDOW）的进程包装
+
+### Fixed
+
+- Windows 平台隐藏控制台窗口配置

Cargo.lock

@@ -23,6 +23,7 @@ pub use client_config::McpClientConfig;
 pub use config::McpServiceConfig;
 pub use process_compat::check_windows_command;
 pub use process_compat::ensure_runtime_path;
+pub use process_compat::prepare_stdio_env;
 pub use tool_filter::ToolFilter;
 
 // Re-export telemetry types when feature is enabled

mcp-common/src/lib.rs

@@ -97,28 +97,94 @@ pub fn check_windows_command(_command: &str) {
 /// 此函数将这些路径插入到给定 PATH 的最前面，确保优先使用应用内置版本，
 /// 即使用户在 MCP 配置的 `env` 中指定了自定义 PATH。
 ///
+/// **按段去重**：将 runtime_path 和现有 PATH 拆分为独立条目，
+/// 先放 runtime 段，再追加 PATH 中不在 runtime 里的段，彻底避免重复。
+///
 /// 如果 `NUWAX_APP_RUNTIME_PATH` 未设置或为空，直接返回原始 PATH。
 pub fn ensure_runtime_path(path: &str) -> String {
     if let Ok(runtime_path) = std::env::var("NUWAX_APP_RUNTIME_PATH") {
         let runtime_path = runtime_path.trim();
         if !runtime_path.is_empty() {
             let sep = if cfg!(windows) { ";" } else { ":" };
-            // 避免重复：如果 PATH 已经以 runtime_path 开头则不重复添加
-            if path == runtime_path
-                || path.starts_with(&format!("{}{}", runtime_path, sep))
-            {
-                return path.to_string();
+
+            // 将 runtime_path 拆成各段
+            let runtime_segments: Vec<&str> =
+                runtime_path.split(sep).filter(|s| !s.is_empty()).collect();
+
+            // 将现有 PATH 拆成各段，去掉已在 runtime 中的
+            let existing_segments: Vec<&str> = path
+                .split(sep)
+                .filter(|s| !s.is_empty() && !runtime_segments.contains(s))
+                .collect();
+
+            let merged: Vec<&str> = runtime_segments
+                .iter()
+                .copied()
+                .chain(existing_segments)
+                .collect();
+
+            let result = merged.join(sep);
+            if result != path {
+                tracing::info!(
+                    "[ProcessCompat] 前置应用内置运行时到 PATH: {}",
+                    runtime_path
+                );
             }
-            tracing::info!(
-                "[ProcessCompat] 前置应用内置运行时到 PATH: {}",
-                runtime_path
-            );
-            return format!("{}{}{}", runtime_path, sep, path);
+            return result;
         }
     }
     path.to_string()
 }
 
+/// 为 stdio 子进程准备最终的 PATH 和过滤后的环境变量。
+///
+/// 统一处理：
+/// 1. 从 config env 或父进程确定基础 PATH
+/// 2. Windows 上追加 npm 全局 bin 目录
+/// 3. 通过 `ensure_runtime_path` 按段去重前置应用内置运行时
+/// 4. 从 config env 中过滤掉 PATH（已单独处理）
+///
+/// 返回 `(Option<final_path>, filtered_env)`，调用方只需 apply 到 `cmd` 即可。
+pub fn prepare_stdio_env(
+    env: &Option<std::collections::HashMap<String, String>>,
+) -> (Option<String>, Option<Vec<(String, String)>>) {
+    // 1. 确定基础 PATH
+    let base_path = if env.as_ref().map_or(true, |e| !e.contains_key("PATH")) {
+        std::env::var("PATH").ok()
+    } else {
+        env.as_ref().and_then(|e| e.get("PATH").cloned())
+    };
+
+    // 2. Windows: 追加 npm 全局 bin + 3. ensure_runtime_path
+    let final_path = base_path.map(|path| {
+        #[cfg(target_os = "windows")]
+        let path = {
+            if let Ok(appdata) = std::env::var("APPDATA") {
+                let npm_path = format!(r"{}\npm", appdata);
+                if !path.contains(&npm_path) {
+                    format!("{};{}", path, npm_path)
+                } else {
+                    path
+                }
+            } else {
+                tracing::warn!("Windows: APPDATA not found, skipping npm global bin");
+                path
+            }
+        };
+        ensure_runtime_path(&path)
+    });
+
+    // 4. 过滤掉 PATH（已单独处理）
+    let filtered_env = env.as_ref().map(|vars| {
+        vars.iter()
+            .filter(|(k, _)| k.as_str() != "PATH")
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    });
+
+    (final_path, filtered_env)
+}
+
 /// 为 process-wrap 8.x 的 TokioCommandWrap 应用平台特定的包装
 ///
 /// 此宏会根据目标平台自动应用正确的进程包装：
@@ -221,4 +287,68 @@ mod tests {
         check_windows_command("npx some-server");
         check_windows_command("test.cmd");
     }
+
+    #[test]
+    fn test_ensure_runtime_path_no_env() {
+        // NUWAX_APP_RUNTIME_PATH 未设置时，返回原始 PATH
+        unsafe { std::env::remove_var("NUWAX_APP_RUNTIME_PATH") };
+        let result = ensure_runtime_path("/usr/bin:/usr/local/bin");
+        assert_eq!(result, "/usr/bin:/usr/local/bin");
+    }
+
+    #[test]
+    fn test_ensure_runtime_path_prepend() {
+        unsafe {
+            std::env::set_var("NUWAX_APP_RUNTIME_PATH", "/app/node/bin:/app/uv/bin");
+        }
+        let result = ensure_runtime_path("/usr/bin:/usr/local/bin");
+        assert_eq!(result, "/app/node/bin:/app/uv/bin:/usr/bin:/usr/local/bin");
+        unsafe { std::env::remove_var("NUWAX_APP_RUNTIME_PATH") };
+    }
+
+    #[test]
+    fn test_ensure_runtime_path_dedup() {
+        // 模拟：PATH 中已有 runtime 的部分段 → 不应重复
+        unsafe {
+            std::env::set_var("NUWAX_APP_RUNTIME_PATH", "/app/node/bin:/app/uv/bin");
+        }
+        let result =
+            ensure_runtime_path("/app/node/bin:/opt/homebrew/bin:/usr/bin");
+        assert_eq!(
+            result,
+            "/app/node/bin:/app/uv/bin:/opt/homebrew/bin:/usr/bin"
+        );
+        unsafe { std::env::remove_var("NUWAX_APP_RUNTIME_PATH") };
+    }
+
+    #[test]
+    fn test_ensure_runtime_path_all_present() {
+        // PATH 已含全部 runtime 段 → 仅调整顺序确保 runtime 在前
+        unsafe {
+            std::env::set_var("NUWAX_APP_RUNTIME_PATH", "/app/node/bin:/app/uv/bin");
+        }
+        let result =
+            ensure_runtime_path("/app/uv/bin:/usr/bin:/app/node/bin");
+        assert_eq!(result, "/app/node/bin:/app/uv/bin:/usr/bin");
+        unsafe { std::env::remove_var("NUWAX_APP_RUNTIME_PATH") };
+    }
+
+    #[test]
+    fn test_ensure_runtime_path_double_node() {
+        // 模拟日志中的问题：node/bin 出现两次
+        unsafe {
+            std::env::set_var(
+                "NUWAX_APP_RUNTIME_PATH",
+                "/app/node/bin:/app/uv/bin:/app/debug",
+            );
+        }
+        let result = ensure_runtime_path(
+            "/app/node/bin:/app/node/bin:/app/uv/bin:/app/debug:/opt/homebrew/bin",
+        );
+        assert_eq!(
+            result,
+            "/app/node/bin:/app/uv/bin:/app/debug:/opt/homebrew/bin"
+        );
+        unsafe { std::env::remove_var("NUWAX_APP_RUNTIME_PATH") };
+    }
 }

mcp-common/src/process_compat.rs

@@ -1,7 +1,7 @@
 [package]
 name = "mcp-stdio-proxy"
 # 主入口版本，与 workspace 对外发布版本一致
-version = "0.1.52"
+version = "0.1.53"
 edition = "2024"
 authors = ["nuwax-ai"]
 description = "MCP (Model Context Protocol) proxy server and CLI tool for protocol conversion and remote service access"

mcp-proxy/Cargo.toml

@@ -297,49 +297,17 @@ impl SseServerBuilder {
         // process-wrap 会自动处理进程组（Unix）或 Job Object（Windows）
         // 并且在 Drop 时自动清理子进程树
         let mut wrapped_cmd = TokioCommandWrap::with_new(command, |cmd| {
-            // 继承父进程的 PATH 环境变量（如果配置中未指定）
-            if env.as_ref().map_or(true, |e| !e.contains_key("PATH")) {
-                if let Ok(path) = std::env::var("PATH") {
-                    info!("[SseServerBuilder] Inheriting PATH from parent process");
-                    // Windows: 添加 npm 全局 bin 目录到 PATH
-                    #[cfg(target_os = "windows")]
-                    let path = {
-                        if let Ok(appdata) = std::env::var("APPDATA") {
-                            let npm_path = format!(r"{}\npm", appdata);
-                            if !path.contains(&npm_path) {
-                                info!(
-                                    "[SseServerBuilder] Windows: Adding npm global bin to PATH: {}",
-                                    npm_path
-                                );
-                                format!("{};{}", path, npm_path)
-                            } else {
-                                info!(
-                                    "[SseServerBuilder] Windows: npm global bin already in PATH: {}",
-                                    npm_path
-                                );
-                                path
-                            }
-                        } else {
-                            warn!(
-                                "[SseServerBuilder] Windows: APPDATA environment variable not found, using original PATH"
-                            );
-                            path
-                        }
-                    };
-                    cmd.env("PATH", path);
-                } else {
-                    warn!(
-                        "[SseServerBuilder] Failed to read PATH environment variable from parent process"
-                    );
-                }
+            let (final_path, filtered_env) = mcp_common::prepare_stdio_env(env);
+            if let Some(path) = final_path {
+                cmd.env("PATH", path);
             } else {
-                info!("[SseServerBuilder] Using PATH from MCP service configuration");
+                warn!("[SseServerBuilder] PATH not available from parent process or config");
             }
             if let Some(cmd_args) = args {
                 cmd.args(cmd_args);
             }
-            if let Some(env_vars) = env {
-                for (k, v) in env_vars {
+            if let Some(vars) = filtered_env {
+                for (k, v) in vars {
                     cmd.env(k, v);
                 }
             }

mcp-sse-proxy/src/server_builder.rs

@@ -181,51 +181,19 @@ impl StreamServerBuilder {
     ) -> Result<rmcp::service::RunningService<rmcp::RoleClient, ClientInfo>> {
         let mut cmd = Command::new(command);
 
-        // 继承父进程的 PATH 环境变量（如果配置中未指定）
-        if env.as_ref().map_or(true, |e| !e.contains_key("PATH")) {
-            if let Ok(path) = std::env::var("PATH") {
-                info!("[StreamServerBuilder] Inheriting PATH from parent process");
-                // Windows: 添加 npm 全局 bin 目录到 PATH
-                #[cfg(target_os = "windows")]
-                let path = {
-                    if let Ok(appdata) = std::env::var("APPDATA") {
-                        let npm_path = format!(r"{}\npm", appdata);
-                        if !path.contains(&npm_path) {
-                            info!(
-                                "[StreamServerBuilder] Windows: Adding npm global bin to PATH: {}",
-                                npm_path
-                            );
-                            format!("{};{}", path, npm_path)
-                        } else {
-                            info!(
-                                "[StreamServerBuilder] Windows: npm global bin already in PATH: {}",
-                                npm_path
-                            );
-                            path
-                        }
-                    } else {
-                        warn!(
-                            "[StreamServerBuilder] Windows: APPDATA environment variable not found, using original PATH"
-                        );
-                        path
-                    }
-                };
-                cmd.env("PATH", path);
-            } else {
-                warn!(
-                    "[StreamServerBuilder] Failed to read PATH environment variable from parent process"
-                );
-            }
+        let (final_path, filtered_env) = mcp_common::prepare_stdio_env(env);
+        if let Some(path) = final_path {
+            cmd.env("PATH", path);
         } else {
-            info!("[StreamServerBuilder] Using PATH from MCP service configuration");
+            warn!("[StreamServerBuilder] PATH not available from parent process or config");
         }
 
         if let Some(cmd_args) = args {
             cmd.args(cmd_args);
         }
 
-        if let Some(env_vars) = env {
-            for (k, v) in env_vars {
+        if let Some(vars) = filtered_env {
+            for (k, v) in vars {
                 cmd.env(k, v);
             }
         }