Skip to content

DeepSeek Harness Tauri 桌面版 | Only 8mb installer, zero environment setup, preset plugins, Windows / macOS / Linux.

58.3 KB
Raw Blame
//! pnpm 选版与版本探测:store 主版本感知(pnpm 10 与 11 的 store 布局互不兼容)、
//! 用户 pnpm 探测(注入桌面端选定 Node 的 PATH,见 issue #182;stdin 关闭、wait/
//! cleanup 全程有界监控,见 probe 机制)、捆绑版按需补齐下载,以及服务启动时的
//! `DSH_PREFER_BUNDLED_PNPM` 决策(启动阶段不触发下载)。
//!
//! 探测只是「优先复用用户 pnpm」的优化:探测进程被强杀并回收干净后的失败
//! (超时/读管道失败/broken shim)一律降级为 `Ok(None)`,由 [`ensure_pnpm`] 回退
//! 捆绑版 pnpm;只有进程状态无法确认时才 fail-closed 返回 `Err`(issue #449)。

use crate::config;
use crate::service::cli;
use crate::service::download;
use crate::service::download::Installable;
use std::ffi::OsString;
use std::io::Read;
use std::path::Path;
#[cfg(test)]
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use tauri::{AppHandle, Emitter, WebviewWindow};

use super::acquire_process_lock;
use super::new_process_owner;
use super::profile_dir;
use super::PidGuard;
use super::PreinstallLogPayload;
use super::ProcessOwner;
use super::PREINSTALL_LOG_EVENT;

const MIN_TRUSTED_PNPM_MAJOR: u32 = 10;
const PNPM_PROBE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
const PNPM_PROBE_CLEANUP_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
const PNPM_PROBE_REAP_RETRY_INTERVAL: std::time::Duration = std::time::Duration::from_millis(25);
const PNPM_PROBE_LIVENESS_INTERVAL: std::time::Duration = std::time::Duration::from_millis(100);

pub(super) async fn ensure_pnpm(
    app_handle: &AppHandle,
    window: &WebviewWindow,
    owner: ProcessOwner,
) -> Result<bool, String> {
    // 档案的 node_modules 由哪个 pnpm 主版本创建(.modules.yaml 的 storeDir 段)
    let store_major = profile_store_major(app_handle);
    let user_major = user_pnpm_major_version_bounded(app_handle, owner).await?;

    // 1) store 主版本已知 → 优先选与 store 一致的 pnpm(用户版或捆绑版)
    if let Some(store) = store_major {
        if user_major == Some(store) {
            log::info!("Reusing user-installed pnpm (major {store}) matching profile store");
            return Ok(false);
        }
        if bundled_pnpm_major(app_handle) == Some(store) {
            log::info!("Using bundled pnpm (major {store}) matching profile store");
            return Ok(true);
        }
        // 本机没有该 store 主版本的 pnpm(捆绑版与用户版都不匹配):档案的安装
        // 元数据已无法与将要使用的 pnpm 兼容,继续跑只会以
        // `ERR_PNPM_UNEXPECTED_STORE` 失败。删掉元数据,让下面选出的 pnpm 以自身
        // 主版本布局重建安装树,而不是明知必败仍发车。
        log::warn!(
            "No pnpm matches profile store major {store} (user {user_major:?}), resetting profile modules metadata"
        );
        if reset_incompatible_modules_metadata(app_handle) {
            let _ = window.emit(
                PREINSTALL_LOG_EVENT,
                PreinstallLogPayload {
                    line: format!(
                        "[pnpm] no pnpm matches this profile's store major {store}; rebuilt the profile modules metadata for the pnpm in use"
                    ),
                },
            );
        }
    }

    // 2) store 未知(全新档案/未装过依赖)或无可匹配版本 → 用户 pnpm ≥ 10 优先
    match user_major {
        Some(major) if major >= MIN_TRUSTED_PNPM_MAJOR => {
            log::info!("Reusing user-installed pnpm (major {major}) for plugin install");
            return Ok(false);
        }
        Some(major) => {
            log::warn!(
                "User pnpm major {major} < {MIN_TRUSTED_PNPM_MAJOR} (missing autoInstallPeers/workspace-root semantics), using bundled pnpm"
            );
        }
        None => {
            log::warn!(
                "User pnpm version not detectable (broken/blocked shim?), using bundled pnpm"
            );
        }
    }

    // 捆绑版已存在 → 直接用(零额外下载);否则下载。
    if config::get_pnpm_binary_path(app_handle).exists() {
        return Ok(true);
    }

    let _ = window.emit(
        PREINSTALL_LOG_EVENT,
        PreinstallLogPayload {
            line: "[pnpm] bundled pnpm not found, downloading before plugin install".to_string(),
        },
    );

    let tracker = download::ProgressTracker::new(window, 2);
    let url = download::Pnpm.get_download_url()?;
    let name = url.split('/').next_back().unwrap_or(&url).to_string();
    let buffer = download::download_file(&tracker, url)
        .await
        .map_err(|e| format!("PNPM_DOWNLOAD_FAILED: {e}"))?;
    download::verify_sha256(&buffer, config::PNPM_SHA256)
        .map_err(|e| format!("PNPM_INTEGRITY_FAILED: {e}"))?;
    let dest = download::Pnpm.get_install_path(app_handle);

    download::ensure_extract(&tracker, name, buffer, dest.clone())
        .await
        .map_err(|e| format!("PNPM_EXTRACT_FAILED: {e}"))?;
    // 捆绑 pnpm 落盘后,该依赖的安装根即托管根(映射表随之更新)。
    config::dependencies::record(app_handle, config::dependencies::DEP_PNPM, Some(dest));

    let _ = window.emit(
        PREINSTALL_LOG_EVENT,
        PreinstallLogPayload {
            line: "[pnpm] bundled pnpm ready".to_string(),
        },
    );
    Ok(true)
}

async fn user_pnpm_major_version_bounded(
    app_handle: &AppHandle,
    owner: ProcessOwner,
) -> Result<Option<u32>, String> {
    let Some(pnpm) = cli::find_user_pnpm(app_handle) else {
        return Ok(None);
    };
    pnpm_major_version_at_bounded(
        &pnpm,
        Some(&config::get_node_binary_path(app_handle)),
        Some(&cli::get_bin_dir(app_handle)),
        owner,
    )
    .await
}

pub(crate) async fn pnpm_major_version_at_bounded(
    pnpm: &Path,
    node: Option<&Path>,
    bin_dir: Option<&Path>,
    owner: ProcessOwner,
) -> Result<Option<u32>, String> {
    let deadline = tokio::time::Instant::now() + PNPM_PROBE_TIMEOUT;
    let mut command = pnpm_probe_command(pnpm, node, bin_dir);
    #[cfg(unix)]
    {
        use std::os::unix::process::CommandExt;
        command.process_group(0);
    }
    let process_guard = tokio::time::timeout_at(deadline, acquire_process_lock())
        .await
        .map_err(|_| {
            "PNPM_PROBE_LOCK_TIMEOUT: timed out waiting for the process lock".to_string()
        })??;
    let child = match command
        .stdout(std::process::Stdio::piped())
        .stderr(std::process::Stdio::piped())
        .spawn()
    {
        Ok(child) => child,
        Err(error) => {
            log_probe_fallback(pnpm, "spawn", error);
            return Ok(None);
        }
    };
    let child = Arc::new(Mutex::new(child));
    let pid_guard = PidGuard::set_child(owner, &child);
    let pending = ProbeCleanupPending {
        child,
        owner,
        _process_guard: process_guard,
        _pid_guard: pid_guard,
    };
    let pnpm = pnpm.to_path_buf();
    // 调用方取消只脱离等待;进程与守卫由独立任务持有到回收完成。
    tauri::async_runtime::spawn(async move {
        let child = pending.child.clone();
        let mut waiter =
            tauri::async_runtime::spawn_blocking(move || wait_for_probe_output(&child));
        let (reason, waiter) = match tokio::time::timeout_at(deadline, &mut waiter).await {
            Ok(Ok(Ok(output))) => {
                if let Some(reason) = super::super::process::process_cleanup_failure(pending.owner)
                {
                    (reason, None)
                } else {
                    pending.release();
                    return Ok(parse_pnpm_major_output(&pnpm, &output));
                }
            }
            Ok(joined) => {
                let reason = match joined {
                    Ok(Err(error)) => format!("PNPM_PROBE_OUTPUT_FAILED: {error}"),
                    Err(error) => format!("PNPM_PROBE_WAIT_TASK_FAILED: {error}"),
                    Ok(Ok(_)) => unreachable!(),
                };
                (reason, None)
            }
            Err(_) => (
                format!(
                    "PNPM_PROBE_TIMEOUT: pnpm version probe exceeded {} seconds",
                    PNPM_PROBE_TIMEOUT.as_secs()
                ),
                Some(waiter),
            ),
        };
        cleanup_probe(pending, waiter, reason.clone()).await?;
        Ok(probe_timeout_or_fallback(&pnpm, reason))
    })
    .await
    .map_err(|error| format!("PNPM_PROBE_TASK_FAILED: {error}"))?
}

struct ProbeCleanupPending {
    child: Arc<Mutex<std::process::Child>>,
    owner: ProcessOwner,
    _process_guard: tokio::sync::OwnedMutexGuard<()>,
    _pid_guard: PidGuard,
}

impl ProbeCleanupPending {
    fn release(self) {
        let Self {
            owner,
            _process_guard,
            _pid_guard,
            ..
        } = self;
        super::super::process::release_process_cleanup(owner, _pid_guard, _process_guard);
    }
}

fn wait_for_probe_output(
    child: &Arc<Mutex<std::process::Child>>,
) -> std::io::Result<std::process::Output> {
    let (stdout, stderr) = {
        let mut child = child.lock().unwrap_or_else(|error| error.into_inner());
        (child.stdout.take(), child.stderr.take())
    };
    std::thread::scope(|scope| {
        let stdout_reader = std::thread::Builder::new()
            .name("pnpm-probe-stdout".to_string())
            .spawn_scoped(scope, move || read_probe_pipe(stdout))?;
        let stderr_reader = std::thread::Builder::new()
            .name("pnpm-probe-stderr".to_string())
            .spawn_scoped(scope, move || read_probe_pipe(stderr))?;
        let stdout = stdout_reader
            .join()
            .map_err(|_| std::io::Error::other("pnpm version probe stdout reader panicked"))??;
        let stderr = stderr_reader
            .join()
            .map_err(|_| std::io::Error::other("pnpm version probe stderr reader panicked"))??;
        let status = loop {
            if let Some(status) = child
                .lock()
                .unwrap_or_else(|error| error.into_inner())
                .try_wait()?
            {
                break status;
            }
            std::thread::sleep(PNPM_PROBE_REAP_RETRY_INTERVAL);
        };
        Ok(std::process::Output {
            status,
            stdout,
            stderr,
        })
    })
}

use super::super::cancel::terminate_probe_tree;

fn terminate_probe(
    child: &Arc<Mutex<std::process::Child>>,
    terminate_tree: fn(u32) -> bool,
) -> std::io::Result<()> {
    let mut child = child.lock().unwrap_or_else(|error| error.into_inner());
    // 同一锁内确认存活并强杀;waiter 不得先回收后再按可能复用的 PID 杀进程。
    if child.try_wait()?.is_none() {
        let tree_killed = terminate_tree(child.id());
        let root_killed = child.kill();
        if !tree_killed {
            return Err(std::io::Error::other(
                "PNPM_PROBE_TREE_CLEANUP_FAILED: pnpm version probe process tree termination was not confirmed",
            ));
        }
        if let Err(error) = root_killed {
            if child.try_wait()?.is_none() {
                return Err(error);
            }
        }
    }
    Ok(())
}

async fn cleanup_probe(
    pending: ProbeCleanupPending,
    waiter: Option<tauri::async_runtime::JoinHandle<std::io::Result<std::process::Output>>>,
    reason: String,
) -> Result<(), String> {
    let mut cleanup = monitor_probe_cleanup(pending, waiter, reason, terminate_probe_tree);
    match tokio::time::timeout(PNPM_PROBE_CLEANUP_TIMEOUT, &mut cleanup).await {
        Ok(Ok(())) => Ok(()),
        Ok(Err(error)) => Err(format!("PNPM_PROBE_CLEANUP_FAILED: {error}")),
        Err(_) => Err(
            "PNPM_PROBE_CLEANUP_TIMEOUT: pnpm version probe cleanup did not finish within 5 seconds"
                .to_string(),
        ),
    }
}

fn monitor_probe_cleanup(
    pending: ProbeCleanupPending,
    waiter: Option<tauri::async_runtime::JoinHandle<std::io::Result<std::process::Output>>>,
    reason: String,
    terminate_tree: fn(u32) -> bool,
) -> tauri::async_runtime::JoinHandle<()> {
    super::super::process::mark_process_cleanup_failed(pending.owner, reason);
    tauri::async_runtime::spawn(async move {
        let child = pending.child.clone();
        let killer =
            tauri::async_runtime::spawn_blocking(move || terminate_probe(&child, terminate_tree));
        let wait = async move {
            if let Some(waiter) = waiter {
                if let Err(error) = waiter.await {
                    log::error!("pnpm version probe cleanup wait task failed: {error}");
                }
            }
        };
        let (killed, ()) = tokio::join!(killer, wait);
        if !matches!(killed, Ok(Ok(()))) {
            let reason = format!(
                "PNPM_PROBE_TREE_CLEANUP_FAILED: pnpm version probe process tree termination was not confirmed: {killed:?}"
            );
            log::error!("{reason}");
            super::super::process::mark_process_cleanup_failed(pending.owner, reason);
            // ponytail: 未确认整树清理仅重启恢复;需自动恢复再跟踪可靠进程树身份。
            std::future::pending::<()>().await;
        }
        wait_for_probe_cleanup(&pending).await;
        if super::super::process::process_cleanup_failure(pending.owner)
            .is_some_and(|reason| reason.starts_with("PNPM_PROBE_TREE_CLEANUP_FAILED:"))
        {
            std::future::pending::<()>().await;
        }
        pending.release();
    })
}

async fn wait_for_probe_cleanup(pending: &ProbeCleanupPending) {
    wait_for_probe_cleanup_with(
        || {
            !matches!(
                pending
                    .child
                    .lock()
                    .unwrap_or_else(|error| error.into_inner())
                    .try_wait(),
                Ok(Some(_))
            )
        },
        PNPM_PROBE_LIVENESS_INTERVAL,
    )
    .await;
}

async fn wait_for_probe_cleanup_with<F>(mut remains_active: F, interval: std::time::Duration)
where
    F: FnMut() -> bool,
{
    while remains_active() {
        tokio::time::sleep(interval).await;
    }
}

fn read_probe_pipe<R: Read>(pipe: Option<R>) -> std::io::Result<Vec<u8>> {
    let mut output = Vec::new();
    if let Some(mut pipe) = pipe {
        pipe.read_to_end(&mut output)?;
    }
    Ok(output)
}

fn log_probe_fallback(pnpm: &Path, phase: &str, error: impl std::fmt::Display) {
    log::warn!(
        "pnpm version probe {phase} failed for {}: {error}; falling back to bundled pnpm",
        pnpm.display()
    );
}

/// 探测超时后进程已被强杀并回收干净时的处置:记降级日志并返回「用户 pnpm
/// 不可用」(`None`),让 [`ensure_pnpm`] 回退捆绑版 pnpm。
///
/// 版本探测只是「优先复用用户 pnpm」的优化,慢探测(corepack 首次下载确认、
/// 杀软扫描等)不该中断整次插件安装(issue #449)。只有清理未确认(进程可能
/// 仍在、锁未释放)的分支才保持 fail-closed 的 `Err`。
fn probe_timeout_or_fallback(pnpm: &Path, reason: String) -> Option<u32> {
    log_probe_fallback(pnpm, "timeout", reason);
    None
}

/// 关闭 stdin 避免 Corepack 交互挂起(issue #449),注入选定 Node 避免陈旧 PATH(issue #182)。
fn pnpm_probe_command(
    pnpm: &Path,
    node: Option<&Path>,
    bin_dir: Option<&Path>,
) -> std::process::Command {
    let mut command = std::process::Command::new(pnpm);
    command.arg("--version");
    if let Some(path) = pnpm_probe_path(pnpm, node, bin_dir) {
        command.env("PATH", path);
    }
    // 探测必须与安装走同一套解析:`build_plugin_envs` 会把候选路径写进 `DSH_PNPM`
    // 并把桌面端 shim 目录前置,`dsh plugin` 经 PATH 命中的正是那个 shim。只测
    // 候选自身会漏掉这条间接层——探测顺利拿到版本,实际安装却在两个 shim 之间
    // 反复 exec 永不返回(症状:日志停在 `dsh plugin install started` 再无下文)。
    if bin_dir.is_some() {
        command.env("DSH_PNPM", pnpm);
    }
    command.stdin(std::process::Stdio::null());
    // 打包版是 GUI 进程(无控制台):版本探测不能弹出可见黑窗。
    #[cfg(windows)]
    {
        use std::os::windows::process::CommandExt;
        command.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
    }
    command
}

fn parse_pnpm_major_output(pnpm: &Path, output: &std::process::Output) -> Option<u32> {
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        log::warn!(
            "pnpm version probe failed for {} with status {}: {}",
            pnpm.display(),
            output.status,
            stderr.trim()
        );
        return None;
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    stdout.split('.').next()?.trim().parse::<u32>().ok()
}

/// 构建 pnpm 探测专用 PATH:**与 `build_plugin_envs` 同序**——桌面端 shim 目录
/// 首位,随后选定 Node 目录、用户 pnpm 所在目录,其余环境保留。
///
/// 顺序必须一致:安装子进程的 PATH 就是 `[bin_dir, node_dir, ...]`,`dsh plugin`
/// 的 `spawnSync("pnpm")` 命中的是 `bin_dir/pnpm`,而该 shim 只会按 `DSH_PNPM`
/// 或 PATH 继续转发。探测若把 `bin_dir` 排到用户 pnpm 之后,就可能解析出与真实
/// 安装不同的 pnpm(Corepack / 转发型 shim 尤其明显),使选出的主版本与实际安装
/// 的不一致;反过来,少了 `bin_dir` 这一层就会漏掉「按 PATH 解析回桌面 shim」的
/// 间接层,得出与安装相反的结论。
fn pnpm_probe_path(pnpm: &Path, node: Option<&Path>, bin_dir: Option<&Path>) -> Option<OsString> {
    let mut paths = Vec::new();
    if let Some(bin_dir) = bin_dir {
        paths.push(bin_dir.to_path_buf());
    }
    // 选定 Node 仍须位于 pnpm shim 目录之前:corepack 目录可能残留另一份 node,
    // bare `node` 应与桌面端预检和后续插件命令使用同一运行时。
    if let Some(parent) = node.and_then(Path::parent) {
        paths.push(parent.to_path_buf());
    }
    if let Some(parent) = pnpm.parent() {
        paths.push(parent.to_path_buf());
    }
    paths.extend(std::env::split_paths(
        &std::env::var_os("PATH").unwrap_or_default(),
    ));
    std::env::join_paths(paths).ok()
}

/// 档案 `node_modules` 使用的 pnpm store 主版本(`<profile>/node_modules/.modules.yaml`
/// 的 `storeDir` 路径段,如 `...\store\v10` → 10)。
///
/// pnpm 10 与 11 的 store 布局互不兼容:用与 store 主版本不一致的 pnpm 更新
/// 已装插件会 `ERR_PNPM_UNEXPECTED_STORE` 退出。档案尚未安装过依赖(没有
/// node_modules)时返回 `None`,由调用方走"全新档案"逻辑。
/// 供 [`ensure_pnpm`] 选版与 [`crate::service::plugin::verify`] 的修复选版共用。
pub(crate) fn profile_store_major(app_handle: &AppHandle) -> Option<u32> {
    profile_store_major_at(&profile_dir(app_handle))
}

pub(crate) fn profile_store_major_at(profile_dir: &Path) -> Option<u32> {
    parse_store_major_from_modules_yaml(&read_modules_yaml_at(profile_dir)?)
}

/// 档案 `node_modules/.modules.yaml` 记录的 pnpm store 基目录(去掉 `v10` 版本段)。
///
/// 与 [`profile_store_major`] 同源,但给出整条路径:pnpm 只在「解析出的 store」与
/// `node_modules/.modules.yaml` 记录的一致时才继续安装,否则 `ERR_PNPM_UNEXPECTED_STORE`。
/// 用户的 pnpm 用户级/全局配置(或 `npm_config_store_dir` 环境变量)可能把 store 指到
/// 别处,而档案早已按自己那份 store 装好——此时任何 `dsh plugin` 安装/升级都会失败,
/// 与插件本身无关。把这个基目录下传给子进程(见 [`super::env::build_plugin_envs`])即可
/// 保证子进程落在与档案一致的那份 store 上。
///
/// 下传的必须是基目录而非记录原文(含版本段):版本段由 pnpm 按自身主版本追加,见
/// [`strip_store_version`]。
pub(crate) fn profile_store_base_dir(app_handle: &AppHandle) -> Option<String> {
    profile_store_base_dir_at(&profile_dir(app_handle))
}

pub(crate) fn profile_store_base_dir_at(profile_dir: &Path) -> Option<String> {
    let store_dir = parse_store_dir_from_modules_yaml(&read_modules_yaml_at(profile_dir)?)?;
    Some(strip_store_version(&store_dir))
}

/// 去掉 store 目录末尾的 pnpm 版本段(`...\store\v10` → `...\store`)。
///
/// pnpm 计算实际 store 时只在「传入路径已以自身 `STORE_VERSION` 结尾」时原样使用,
/// 否则追加自己的版本段(`getStorePath`)。下传带版本段的路径只在 pnpm 主版本与
/// 档案一致时才等价:主版本不一致时会拼出不存在的嵌套路径(`store\v10\v11`),
/// 与 `.modules.yaml` 的记录必然失配。去掉版本段后由 pnpm 自行补齐 —— 一致时结果
/// 完全相同,不一致时也落在同一份 store 的兄弟目录,不会多出一个位置。末尾不是
/// `v<数字>` 段(包含路径本身就是版本段名)时原样返回。
fn strip_store_version(store_dir: &str) -> String {
    let trimmed = store_dir.trim_end_matches(['\\', '/']);
    let last = trimmed.rsplit(['\\', '/']).next().unwrap_or_default();
    let keep = trimmed.len() - last.len();
    let digits = last.strip_prefix('v').unwrap_or_default();
    if keep == 0 || digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
        return store_dir.to_string();
    }
    trimmed[..keep].trim_end_matches(['\\', '/']).to_string()
}

/// 删除档案的 pnpm 安装元数据(`node_modules/.modules.yaml`),让 pnpm 以当前
/// 主版本重建安装树;返回是否真的删掉了文件。
///
/// pnpm 只在 `.modules.yaml` 存在时做兼容性校验(`checkCompatibility`:先
/// `layoutVersion`,再 `storeDir`、`virtualStoreDir`),而 `storeDir` 记的是解析后的
/// **完整**路径(含 `v10`/`v11` 版本段)。档案由 pnpm 10 安装、本机只剩 pnpm 11
/// 时,pnpm 11 解析出的 store 与记录必然不同,任何安装/升级都以
/// `ERR_PNPM_UNEXPECTED_STORE` 失败 —— 档案本身健康,用户看到的却只是「插件安装
/// 失败」。该文件是纯元数据,删掉后 pnpm 跳过校验、按当前 pnpm 的 store 布局重新
/// 链接(与 `service::migrate` 处理 `ERR_PNPM_UNEXPECTED_VIRTUAL_STORE` 的做法一致)。
pub(crate) fn reset_incompatible_modules_metadata(app_handle: &AppHandle) -> bool {
    let modules_yaml = profile_dir(app_handle)
        .join("node_modules")
        .join(".modules.yaml");
    if !modules_yaml.is_file() {
        return false;
    }
    match std::fs::remove_file(&modules_yaml) {
        Ok(()) => {
            log::info!(
                "reset incompatible pnpm modules metadata: {}",
                modules_yaml.display()
            );
            true
        }
        Err(e) => {
            log::warn!("reset {} failed: {e}", modules_yaml.display());
            false
        }
    }
}

/// 读取档案的 `node_modules/.modules.yaml`;文件缺失(全新档案)返回 `None`。
fn read_modules_yaml_at(profile_dir: &Path) -> Option<String> {
    std::fs::read_to_string(profile_dir.join("node_modules").join(".modules.yaml")).ok()
}

/// 从 `.modules.yaml` 文本解析 `storeDir`(纯函数,便于单测)。
///
/// pnpm 落盘该文件可能是 YAML 块结构,也可能是 **JSON 流结构**(pnpm 11 实测输出
/// `{ "storeDir": "..." }`)。旧实现按行前缀匹配裸 `storeDir:`,遇到 JSON 形态
/// 恒定返回 None,于是 `profile_store_major` 永远未知:store 主版本选版、
/// `reset_incompatible_modules_metadata` 与 `pnpm_config_store_dir` 下传全部静默
/// 失效(症状是 `ensure_pnpm` 打「for plugin install」而不是「matching profile
/// store」、`build_plugin_envs` 从不打 store 固定日志)。JSON 是 YAML 的子集,
/// 统一按 YAML 解析即可覆盖两种形态;转义也交给解析器,不再手工替换 `\\`。
fn parse_store_dir_from_modules_yaml(content: &str) -> Option<String> {
    let value: serde_yaml::Value = serde_yaml::from_str(content).ok()?;
    let raw = value.get("storeDir")?.as_str()?.trim();
    if raw.is_empty() {
        return None;
    }
    Some(raw.to_string())
}

/// 从 `.modules.yaml` 文本解析 store 主版本(纯函数,便于单测)。
fn parse_store_major_from_modules_yaml(content: &str) -> Option<u32> {
    // storeDir 形如 `C:\Users\xx\AppData\Local\pnpm\store\v10`,取末段 `v10` 的数字
    let store_dir = parse_store_dir_from_modules_yaml(content)?;
    let major = store_dir.rsplit(['\\', '/']).next()?.strip_prefix('v')?;
    major.parse().ok()
}

/// 捆绑版 pnpm 的主版本(读 `dependencies/pnpm/package.json` 的 version 字段);
/// 未安装或清单缺失返回 None。
///
/// 供 [`ensure_pnpm`] 选版与 [`crate::service::plugin::verify`] 的修复选版共用(store 主版本匹配)。
pub(crate) fn bundled_pnpm_major(app_handle: &AppHandle) -> Option<u32> {
    bundled_pnpm_major_at(&config::get_pnpm_install_path(app_handle))
}

pub(crate) fn bundled_pnpm_major_at(pnpm_root: &Path) -> Option<u32> {
    let content = std::fs::read_to_string(pnpm_root.join("package.json")).ok()?;
    let value: serde_json::Value = serde_json::from_str(&content).ok()?;
    value
        .get("version")?
        .as_str()?
        .split('.')
        .next()?
        .parse()
        .ok()
}

/// 服务启动阶段的 `DSH_PREFER_BUNDLED_PNPM` 决策:store 主版本已知时只在捆绑版
/// 匹配且用户版不匹配时强制捆绑版(否则用户版会 `ERR_PNPM_UNEXPECTED_STORE`);
/// store 未知时用户 pnpm ≥ 10 优先,否则强制捆绑版。启动阶段绝不触发下载,
/// 捆绑版未安装即返回 false(交由用户 pnpm)。
pub(crate) async fn harness_prefer_bundled_pnpm(app_handle: &AppHandle) -> Result<bool, String> {
    harness_prefer_bundled_pnpm_from(
        &profile_dir(app_handle),
        &config::get_pnpm_install_path(app_handle),
        &config::get_pnpm_binary_path(app_handle),
        cli::find_user_pnpm(app_handle).as_deref(),
        &config::get_node_binary_path(app_handle),
        &cli::get_bin_dir(app_handle),
    )
    .await
}

pub(crate) async fn harness_prefer_bundled_pnpm_from(
    profile_dir: &Path,
    pnpm_root: &Path,
    pnpm_binary: &Path,
    user_pnpm: Option<&Path>,
    node: &Path,
    bin_dir: &Path,
) -> Result<bool, String> {
    if !pnpm_binary.exists() {
        return Ok(false);
    }
    let store_major = profile_store_major_at(profile_dir);
    if store_major.is_some_and(|store| bundled_pnpm_major_at(pnpm_root) != Some(store)) {
        return Ok(false);
    }
    let user_major = match user_pnpm {
        Some(pnpm) => {
            pnpm_major_version_at_bounded(pnpm, Some(node), Some(bin_dir), new_process_owner())
                .await?
        }
        None => None,
    };
    Ok(match store_major {
        Some(store) => user_major != Some(store),
        None => !matches!(user_major, Some(major) if major >= MIN_TRUSTED_PNPM_MAJOR),
    })
}

#[cfg(test)]
mod tests {
    use super::super::super::process::TEST_PROCESS_LOCK;
    use super::*;

    #[tokio::test]
    async fn startup_pnpm_paths_reread_metadata_and_skip_unneeded_probes() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        let root = tempfile::tempdir().unwrap();
        let profile = root.path().join("profile");
        let modules = profile.join("node_modules").join(".modules.yaml");
        let pnpm_root = root.path().join("pnpm");
        let manifest = pnpm_root.join("package.json");
        let binary = pnpm_root.join("bin").join("pnpm.cjs");
        let user = root.path().join("must-not-be-probed");
        let node = root.path().join("node");
        let bin_dir = root.path().join("desktop-bin");
        std::fs::create_dir_all(modules.parent().unwrap()).unwrap();
        std::fs::create_dir_all(binary.parent().unwrap()).unwrap();
        let yaml = "storeDir: /store/v10\n";
        std::fs::write(&modules, yaml).unwrap();
        std::fs::write(&manifest, r#"{"version":"11.2.0"}"#).unwrap();
        assert_eq!(read_modules_yaml_at(&profile).as_deref(), Some(yaml));
        assert_eq!(profile_store_major_at(&profile), Some(10));
        assert_eq!(
            profile_store_base_dir_at(&profile).as_deref(),
            Some("/store")
        );
        assert_eq!(bundled_pnpm_major_at(&pnpm_root), Some(11));

        let process_guard = acquire_process_lock().await.unwrap();
        for present in [false, true] {
            if present {
                std::fs::write(&binary, "").unwrap();
            }
            let prefer = tokio::time::timeout(
                std::time::Duration::from_millis(100),
                harness_prefer_bundled_pnpm_from(
                    &profile,
                    &pnpm_root,
                    &binary,
                    Some(&user),
                    &node,
                    &bin_dir,
                ),
            )
            .await
            .expect("missing or incompatible bundled pnpm must not acquire the probe lock")
            .unwrap();
            assert!(!prefer);
        }
        drop(process_guard);

        for store in [11, 10] {
            let json = format!(r#"{{"storeDir":"/store/v{store}"}}"#);
            std::fs::write(&modules, &json).unwrap();
            assert_eq!(profile_store_major_at(&profile), Some(store));
            assert_eq!(
                profile_store_base_dir_at(&profile).as_deref(),
                Some("/store")
            );
            assert_eq!(
                harness_prefer_bundled_pnpm_from(
                    &profile, &pnpm_root, &binary, None, &node, &bin_dir,
                )
                .await
                .unwrap(),
                store == 11
            );
            assert_eq!(std::fs::read_to_string(&modules).unwrap(), json);
        }
        std::fs::write(&manifest, r#"{"version":"10.9.0"}"#).unwrap();
        assert_eq!(bundled_pnpm_major_at(&pnpm_root), Some(10));
        assert!(harness_prefer_bundled_pnpm_from(
            &profile, &pnpm_root, &binary, None, &node, &bin_dir,
        )
        .await
        .unwrap());
    }

    /// issue #449 回归:探测超时、但进程已被强杀并回收干净时,必须降级为
    /// 「用户 pnpm 不可用」(`None` → `ensure_pnpm` 回退捆绑版),而不是把
    /// `PNPM_PROBE_TIMEOUT` 当成整次插件安装的失败。
    #[test]
    fn pnpm_probe_timeout_after_recycled_cleanup_falls_back_to_bundled() {
        let pnpm = PathBuf::from("slow-pnpm");
        let fallback = probe_timeout_or_fallback(
            &pnpm,
            "PNPM_PROBE_TIMEOUT: pnpm version probe exceeded 10 seconds".to_string(),
        );

        assert!(
            fallback.is_none(),
            "recovered probe timeout must degrade to bundled pnpm, not fail the install"
        );
    }

    /// issue #449 根因:探测命令必须显式关闭 stdin。corepack 版本未缓存时会先
    /// 等待 "Do you want to continue? [Y/n]" 输入,继承 GUI 进程的 stdin 会让
    /// 探测挂到超时(随后只能强杀);这里用「读 stdin 才结束」的假 pnpm 走真实
    /// 的有界探测启动方式(`spawn` + 管道),验证 stdin 关闭后立即拿到版本输出。
    ///
    /// 兜底等待:即使回归(stdin 被继承)也只是超时失败并强杀子进程,不会挂住
    /// 测试进程;stdin 恰好是 /dev/null 的非交互环境无法区分两者,此测试在该
    /// 环境下退化为「探测可用性」检查。
    #[cfg(unix)]
    #[test]
    fn pnpm_probe_command_closes_stdin_for_interactive_shims() {
        use std::os::unix::fs::PermissionsExt;
        use std::time::{SystemTime, UNIX_EPOCH};

        let nonce = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let root = std::env::temp_dir().join(format!(
            "dsh-pnpm-probe-stdin-{}-{nonce}",
            std::process::id()
        ));
        std::fs::create_dir_all(&root).unwrap();
        // stdin 关闭 → `read` 立即 EOF;stdin 被继承 → `read` 阻塞。
        let pnpm = root.join("interactive-pnpm");
        std::fs::write(&pnpm, "#!/bin/sh\nread _\nprintf '11.0.0\\n'\n").unwrap();
        let mut permissions = std::fs::metadata(&pnpm).unwrap().permissions();
        permissions.set_mode(0o700);
        std::fs::set_permissions(&pnpm, permissions).unwrap();

        let mut child = pnpm_probe_command(&pnpm, None, None)
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped())
            .spawn()
            .unwrap();
        let stdout = child.stdout.take().unwrap();
        let (sender, receiver) = std::sync::mpsc::channel();
        let reader = std::thread::spawn(move || {
            let mut buffer = String::new();
            let _ = std::io::BufReader::new(stdout).read_to_string(&mut buffer);
            let _ = sender.send(buffer);
        });

        let output = match receiver.recv_timeout(std::time::Duration::from_secs(5)) {
            Ok(output) => output,
            Err(_) => {
                let _ = child.kill();
                let _ = child.wait();
                panic!("pnpm version probe must not inherit stdin (it blocks on input)");
            }
        };
        let status = child.wait().unwrap();
        let _ = reader.join();

        assert!(status.success());
        assert_eq!(output, "11.0.0\n");
        let _ = std::fs::remove_dir_all(root);
    }

    #[tokio::test]
    async fn pnpm_probe_cleanup_monitor_releases_after_process_disappears() {
        let polls = std::sync::atomic::AtomicUsize::new(0);
        tokio::time::timeout(
            std::time::Duration::from_millis(50),
            wait_for_probe_cleanup_with(
                || polls.fetch_add(1, std::sync::atomic::Ordering::SeqCst) < 2,
                std::time::Duration::from_millis(1),
            ),
        )
        .await
        .expect("cleanup monitor should release after liveness turns false");
        assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
    }

    #[tokio::test]
    async fn pnpm_probe_cleanup_monitor_stays_fail_closed_while_process_lives() {
        let pending = tokio::time::timeout(
            std::time::Duration::from_millis(5),
            wait_for_probe_cleanup_with(|| true, std::time::Duration::from_millis(1)),
        )
        .await;
        assert!(pending.is_err());
    }

    #[tokio::test]
    async fn exited_probe_releases_its_pid_and_process_guard() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let mut child = {
            use std::os::windows::process::CommandExt;
            std::process::Command::new("cmd.exe")
                .creation_flags(0x08000000)
                .args(["/D", "/C", "exit 0"])
                .spawn()
                .unwrap()
        };
        #[cfg(not(windows))]
        let mut child = std::process::Command::new("sh")
            .args(["-c", "exit 0"])
            .spawn()
            .unwrap();
        let pid = child.id();
        assert!(child.wait().unwrap().success());
        let owner = super::super::super::process::new_process_owner();
        let pid_guard = PidGuard::set(owner, pid);
        let lock = std::sync::Arc::new(tokio::sync::Mutex::new(()));
        let process_guard = lock.clone().lock_owned().await;
        assert!(lock.try_lock().is_err());
        cleanup_probe(
            ProbeCleanupPending {
                child: Arc::new(Mutex::new(child)),
                owner,
                _process_guard: process_guard,
                _pid_guard: pid_guard,
            },
            None,
            "PNPM_PROBE_WAIT_TASK_FAILED: test cleanup".to_string(),
        )
        .await
        .unwrap();
        assert_eq!(super::super::super::process::active_plugin_pid(owner), None);
        assert!(lock.try_lock().is_ok());
    }

    #[tokio::test]
    async fn live_probe_retains_its_pid_and_process_guard_until_exit() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let mut command = {
            use std::os::windows::process::CommandExt;
            let mut command = std::process::Command::new("cmd.exe");
            command
                .creation_flags(0x08000000)
                .args(["/D", "/C", "set /p token="]);
            command
        };
        #[cfg(not(windows))]
        let mut command = {
            let mut command = std::process::Command::new("sh");
            command.args(["-c", "read -r token"]);
            command
        };
        let mut child = command
            .stdin(std::process::Stdio::piped())
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .spawn()
            .unwrap();
        let pid = child.id();
        let owner = super::super::super::process::new_process_owner();
        let pid_guard = PidGuard::set(owner, pid);
        let lock = std::sync::Arc::new(tokio::sync::Mutex::new(()));
        let process_guard = lock.clone().lock_owned().await;
        let mut input = child.stdin.take().unwrap();
        let pending = ProbeCleanupPending {
            child: Arc::new(Mutex::new(child)),
            owner,
            _process_guard: process_guard,
            _pid_guard: pid_guard,
        };
        let release = async {
            wait_for_probe_cleanup(&pending).await;
            pending.release();
        };
        tokio::pin!(release);
        assert!(
            tokio::time::timeout(std::time::Duration::from_millis(50), &mut release)
                .await
                .is_err()
        );
        assert_eq!(
            super::super::super::process::active_plugin_pid(owner),
            Some(pid)
        );
        assert!(lock.try_lock().is_err());
        use std::io::Write;
        input.write_all(b"done\n").unwrap();
        tokio::time::timeout(std::time::Duration::from_secs(5), &mut release)
            .await
            .unwrap();
        assert_eq!(super::super::super::process::active_plugin_pid(owner), None);
        assert!(lock.try_lock().is_ok());
    }

    struct BrokenPipeReader;

    impl std::io::Read for BrokenPipeReader {
        fn read(&mut self, _buffer: &mut [u8]) -> std::io::Result<usize> {
            Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "probe output pipe closed",
            ))
        }
    }

    #[test]
    fn pnpm_probe_broken_output_pipe_is_reported_as_fallback_failure() {
        let error = read_probe_pipe(Some(BrokenPipeReader)).unwrap_err();
        assert_eq!(error.kind(), std::io::ErrorKind::BrokenPipe);
    }

    #[cfg(unix)]
    #[tokio::test]
    async fn pnpm_major_version_at_probes_the_exact_selected_path() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        use std::os::unix::fs::PermissionsExt;
        use std::time::{SystemTime, UNIX_EPOCH};

        let nonce = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let root =
            std::env::temp_dir().join(format!("dsh-pnpm-major-{}-{nonce}", std::process::id()));
        std::fs::create_dir_all(&root).unwrap();
        let selected = root.join("selected-pnpm");
        let other = root.join("other-pnpm");
        std::fs::write(&selected, "#!/bin/sh\nprintf '11.2.0\\n'\n").unwrap();
        std::fs::write(&other, "#!/bin/sh\nprintf '10.9.0\\n'\n").unwrap();
        for path in [&selected, &other] {
            let mut permissions = std::fs::metadata(path).unwrap().permissions();
            permissions.set_mode(0o700);
            std::fs::set_permissions(path, permissions).unwrap();
        }

        for (path, major) in [(&selected, 11), (&other, 10)] {
            assert_eq!(
                pnpm_major_version_at_bounded(path, None, None, new_process_owner())
                    .await
                    .unwrap(),
                Some(major)
            );
        }
        let _ = std::fs::remove_dir_all(root);
    }

    /// 回归 Windows GUI 的陈旧 PATH:pnpm shim 必须解析到桌面端选定的 Node,
    /// 即使 shim 同目录存在冲突的 node,且路径包含空格和 shell 元字符。
    #[cfg(windows)]
    #[tokio::test]
    async fn pnpm_major_version_probe_injects_selected_node_for_cmd_shim() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        use std::time::{SystemTime, UNIX_EPOCH};

        let nonce = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let root =
            std::env::temp_dir().join(format!("dsh pnpm cmd major {} {nonce}", std::process::id()));
        let pnpm_dir = root.join("pnpm & corepack");
        let node_dir = root.join("selected node");
        std::fs::create_dir_all(&pnpm_dir).unwrap();
        std::fs::create_dir_all(&node_dir).unwrap();
        let selected = pnpm_dir.join("pnpm.cmd");
        let node = node_dir.join("node.cmd");
        std::fs::write(&selected, "@echo off\r\nnode --version\r\n").unwrap();
        // shim 目录里的冲突运行时若优先会输出 9;选定 Node 必须抢在它前面。
        std::fs::write(pnpm_dir.join("node.cmd"), "@echo off\r\necho 9.0.0\r\n").unwrap();
        std::fs::write(&node, "@echo off\r\necho 11.24.0\r\n").unwrap();

        assert_eq!(
            pnpm_major_version_at_bounded(&selected, Some(&node), None, new_process_owner())
                .await
                .unwrap(),
            Some(11)
        );
        let _ = std::fs::remove_dir_all(root);
    }

    #[tokio::test]
    async fn pnpm_version_probe_bounds_slow_shims_and_releases_the_process_lock() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        let root = tempfile::tempdir().unwrap();
        #[cfg(windows)]
        let pnpm = {
            let pnpm = root.path().join("slow pnpm.cmd");
            std::fs::write(
                &pnpm,
                "@echo off\r\npowershell.exe -NoProfile -NonInteractive -Command \"Start-Sleep -Seconds 20\"\r\necho 11.2.0\r\n",
            )
            .unwrap();
            pnpm
        };
        #[cfg(unix)]
        let pnpm = {
            use std::os::unix::fs::PermissionsExt;
            let pnpm = root.path().join("slow-pnpm");
            std::fs::write(&pnpm, "#!/bin/sh\nsleep 20\nprintf '11.2.0\\n'\n").unwrap();
            std::fs::set_permissions(&pnpm, std::fs::Permissions::from_mode(0o700)).unwrap();
            pnpm
        };
        let started = std::time::Instant::now();
        assert_eq!(
            pnpm_major_version_at_bounded(&pnpm, None, None, new_process_owner())
                .await
                .unwrap(),
            None
        );
        assert!(started.elapsed() < std::time::Duration::from_secs(18));
        let process_guard =
            tokio::time::timeout(std::time::Duration::from_secs(1), acquire_process_lock())
                .await
                .expect("finished probe must release the process lock")
                .unwrap();
        drop(process_guard);
    }

    #[tokio::test]
    async fn cancelled_probe_keeps_its_pid_and_lock_until_the_child_exits() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        let root = tempfile::tempdir().unwrap();
        let release = root.path().join("release");
        #[cfg(windows)]
        let pnpm = {
            let pnpm = root.path().join("held pnpm.cmd");
            let path = release.to_string_lossy().replace('\'', "''");
            std::fs::write(
                &pnpm,
                format!("@echo off\r\npowershell.exe -NoProfile -NonInteractive -Command \"while (-not (Test-Path -LiteralPath '{path}')) {{ Start-Sleep -Milliseconds 25 }}\"\r\necho 11.2.0\r\n"),
            )
            .unwrap();
            pnpm
        };
        #[cfg(unix)]
        let pnpm = {
            use std::os::unix::fs::PermissionsExt;
            let pnpm = root.path().join("held-pnpm");
            let path = release.to_string_lossy().replace('\'', "'\\''");
            std::fs::write(
                &pnpm,
                format!("#!/bin/sh\nwhile [ ! -f '{path}' ]; do sleep 0.025; done\nprintf '11.2.0\\n'\n"),
            )
            .unwrap();
            std::fs::set_permissions(&pnpm, std::fs::Permissions::from_mode(0o700)).unwrap();
            pnpm
        };
        let owner = new_process_owner();
        let caller =
            tokio::spawn(
                async move { pnpm_major_version_at_bounded(&pnpm, None, None, owner).await },
            );
        let pid = tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                if let Some(pid) = super::super::super::process::active_plugin_pid(owner) {
                    break pid;
                }
                tokio::task::yield_now().await;
            }
        })
        .await
        .unwrap();
        caller.abort();
        assert!(caller.await.unwrap_err().is_cancelled());
        let retained_pid = super::super::super::process::active_plugin_pid(owner);
        let held_lock =
            tokio::time::timeout(std::time::Duration::from_millis(50), acquire_process_lock())
                .await;
        std::fs::write(release, "done").unwrap();
        let released =
            tokio::time::timeout(std::time::Duration::from_secs(5), acquire_process_lock())
                .await
                .unwrap()
                .unwrap();
        assert_eq!(retained_pid, Some(pid));
        assert!(
            held_lock.is_err(),
            "cancelled caller must not release a live probe lock"
        );
        assert_eq!(super::super::super::process::active_plugin_pid(owner), None);
        drop(released);
    }

    #[tokio::test]
    async fn cleanup_timeout_fails_closed_until_the_waiter_finishes() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let mut child = {
            use std::os::windows::process::CommandExt;
            std::process::Command::new("cmd.exe")
                .creation_flags(0x08000000)
                .args(["/D", "/C", "exit 0"])
                .spawn()
                .unwrap()
        };
        #[cfg(unix)]
        let mut child = std::process::Command::new("sh")
            .args(["-c", "exit 0"])
            .spawn()
            .unwrap();
        let pid = child.id();
        child.wait().unwrap();
        let owner = new_process_owner();
        let process_guard = acquire_process_lock().await.unwrap();
        let pending = ProbeCleanupPending {
            child: Arc::new(Mutex::new(child)),
            owner,
            _process_guard: process_guard,
            _pid_guard: PidGuard::set(owner, pid),
        };
        let (release, held) = tokio::sync::oneshot::channel::<()>();
        let waiter = tauri::async_runtime::spawn(async move {
            held.await.unwrap();
            Err(std::io::Error::other("probe output pipe closed"))
        });
        let started = std::time::Instant::now();
        let result = cleanup_probe(
            pending,
            Some(waiter),
            "PNPM_PROBE_WAIT_TASK_FAILED: held waiter".to_string(),
        )
        .await;
        let retained_pid = super::super::super::process::active_plugin_pid(owner);
        let blocked =
            tokio::time::timeout(std::time::Duration::from_millis(50), acquire_process_lock())
                .await;
        release.send(()).unwrap();
        let released = tokio::time::timeout(std::time::Duration::from_secs(2), async {
            while super::super::super::process::active_plugin_pid(owner).is_some() {
                tokio::task::yield_now().await;
            }
            acquire_process_lock().await
        })
        .await
        .unwrap()
        .unwrap();
        assert!(result
            .unwrap_err()
            .starts_with("PNPM_PROBE_CLEANUP_TIMEOUT:"));
        assert!(started.elapsed() < std::time::Duration::from_secs(7));
        assert_eq!(retained_pid, Some(pid));
        assert!(blocked
            .unwrap()
            .unwrap_err()
            .starts_with("PNPM_PROBE_WAIT_TASK_FAILED:"));
        assert_eq!(super::super::super::process::active_plugin_pid(owner), None);
        drop(released);
    }

    #[tokio::test]
    async fn failed_tree_termination_retains_guards_even_after_root_exit() {
        let _test_guard = TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let mut command = {
            use std::os::windows::process::CommandExt;
            let mut command = std::process::Command::new("cmd.exe");
            command
                .creation_flags(0x08000000)
                .args(["/D", "/C", "set /p token="]);
            command
        };
        #[cfg(unix)]
        let mut command = {
            use std::os::unix::process::CommandExt;
            let mut command = std::process::Command::new("sh");
            command.args(["-c", "read -r token"]).process_group(0);
            command
        };
        let child = Arc::new(Mutex::new(
            command
                .stdin(std::process::Stdio::piped())
                .stdout(std::process::Stdio::piped())
                .stderr(std::process::Stdio::piped())
                .spawn()
                .unwrap(),
        ));
        let pid = child.lock().unwrap().id();
        let owner = new_process_owner();
        let lock = Arc::new(tokio::sync::Mutex::new(()));
        let pending = ProbeCleanupPending {
            child: child.clone(),
            owner,
            _process_guard: lock.clone().lock_owned().await,
            _pid_guard: PidGuard::set(owner, pid),
        };
        let waiting_child = child.clone();
        let waiter =
            tauri::async_runtime::spawn_blocking(move || wait_for_probe_output(&waiting_child));
        let mut monitor = monitor_probe_cleanup(
            pending,
            Some(waiter),
            "PNPM_PROBE_TIMEOUT: injected tree termination failure".to_string(),
            |_| false,
        );
        let exited = tokio::time::timeout(std::time::Duration::from_secs(2), async {
            while child.lock().unwrap().try_wait().unwrap().is_none() {
                tokio::time::sleep(PNPM_PROBE_REAP_RETRY_INTERVAL).await;
            }
        })
        .await;
        let failure = tokio::time::timeout(std::time::Duration::from_secs(2), async {
            loop {
                if let Err(reason) = acquire_process_lock().await {
                    if reason.starts_with("PNPM_PROBE_TREE_CLEANUP_FAILED:") {
                        break reason;
                    }
                }
                tokio::task::yield_now().await;
            }
        })
        .await;
        let retained_pid = super::super::super::process::active_plugin_pid(owner);
        let lock_held = lock.try_lock().is_err();
        let retained = tokio::time::timeout(std::time::Duration::from_millis(50), &mut monitor)
            .await
            .is_err();
        if retained {
            monitor.abort();
            let _ = monitor.await;
        }
        super::super::super::process::clear_process_cleanup_failed(owner);
        if exited.is_err() {
            let mut child = child.lock().unwrap();
            let _ = child.kill();
            let _ = child.wait();
        }
        assert!(
            exited.is_ok(),
            "root fallback must kill the real probe child"
        );
        assert!(
            failure.is_ok(),
            "root exit must not clear unconfirmed tree cleanup"
        );
        assert!(retained, "tree failure must retain the cleanup monitor");
        assert!(lock_held, "tree failure must retain the process guard");
        assert_eq!(retained_pid, Some(pid));
        assert_eq!(super::super::super::process::active_plugin_pid(owner), None);
        assert!(lock.try_lock().is_ok());
    }

    #[test]
    fn store_major_parsed_from_modules_yaml() {
        // 真实 pnpm v10 写入的 .modules.yaml:storeDir 指向 store\v10
        let content = "\
lockfileVersion: '9.0'
settings:
  autoInstallPeers: true
  excludeLinksFromLockfile: false
dependencies:
  '@deepseek-ai/dsh-base': 0.0.4
  '@deepseek-ai/dsh-web-app': 0.0.4
storeDir: C:\\Users\\test\\AppData\\Local\\pnpm\\store\\v10
virtualStoreDir: node_modules/.pnpm
";
        assert_eq!(parse_store_major_from_modules_yaml(content), Some(10));
    }

    #[test]
    fn store_major_supports_unix_and_quoted_paths() {
        assert_eq!(
            parse_store_major_from_modules_yaml(
                "storeDir: /home/test/.local/share/pnpm/store/v11\n"
            ),
            Some(11)
        );
        assert_eq!(
            parse_store_major_from_modules_yaml("storeDir: \"C:\\\\pnpm store\\\\v3\"\n"),
            Some(3)
        );
    }

    #[test]
    fn store_major_missing_when_no_store_dir() {
        // 档案尚未装过依赖:无 storeDir 段 → None
        assert_eq!(
            parse_store_major_from_modules_yaml("lockfileVersion: '9.0'\n"),
            None
        );
        assert_eq!(parse_store_major_from_modules_yaml(""), None);
        // storeDir 存在但没有版本段(理论上不该出现)→ 无法判定主版本
        assert_eq!(
            parse_store_major_from_modules_yaml("storeDir: C:\\Users\\x\\pnpm\\store\n"),
            None
        );
    }

    #[test]
    fn store_dir_parsed_for_handoff_to_pnpm() {
        // 解析必须保留记录原文(含 v10 版本段),由 strip_store_version 决定下传什么
        let content = "\
hoistPattern:
  - '*'
storeDir: C:\\Users\\test\\AppData\\Local\\pnpm\\store\\v10
virtualStoreDir: node_modules/.pnpm
";
        assert_eq!(
            parse_store_dir_from_modules_yaml(content).as_deref(),
            Some("C:\\Users\\test\\AppData\\Local\\pnpm\\store\\v10")
        );
        assert_eq!(
            parse_store_dir_from_modules_yaml("storeDir: /home/test/.local/share/pnpm/store/v11\n")
                .as_deref(),
            Some("/home/test/.local/share/pnpm/store/v11")
        );
        // YAML 双引号形式:去引号并把 `\\` 还原成单个反斜杠
        assert_eq!(
            parse_store_dir_from_modules_yaml("storeDir: \"C:\\\\pnpm store\\\\v3\"\n").as_deref(),
            Some("C:\\pnpm store\\v3")
        );
        assert_eq!(
            parse_store_dir_from_modules_yaml("storeDir: 'D:\\.pnpm-store\\v10'\n").as_deref(),
            Some("D:\\.pnpm-store\\v10")
        );
        // 缺失 / 空值 → None(全新档案不注入环境变量)
        assert_eq!(parse_store_dir_from_modules_yaml("storeDir:\n"), None);
        assert_eq!(
            parse_store_dir_from_modules_yaml("lockfileVersion: '9.0'\n"),
            None
        );
    }

    /// 回归:pnpm 11 把 `.modules.yaml` 写成 JSON 流结构(`"storeDir": "..."`)。
    /// 旧实现按行前缀匹配裸 `storeDir:`,对真实文件恒定失败,导致 store 主版本
    /// 感知、元数据重置与 store 下传全部静默失效。
    #[test]
    fn store_dir_parsed_from_json_modules_yaml() {
        let content = r#"{
  "hoistPattern": [
    "*"
  ],
  "layoutVersion": 5,
  "storeDir": "/Users/ruan/Library/pnpm/store/v11",
  "virtualStoreDir": "node_modules/.pnpm"
}"#;
        assert_eq!(
            parse_store_dir_from_modules_yaml(content).as_deref(),
            Some("/Users/ruan/Library/pnpm/store/v11")
        );
        assert_eq!(parse_store_major_from_modules_yaml(content), Some(11));

        // JSON 双引号里的 `\\` 由解析器还原为单个反斜杠(Windows 档案同样命中)。
        let windows = r#"{"storeDir": "C:\\Users\\test\\AppData\\Local\\pnpm\\store\\v10"}"#;
        assert_eq!(
            parse_store_dir_from_modules_yaml(windows).as_deref(),
            Some(r"C:\Users\test\AppData\Local\pnpm\store\v10")
        );
        assert_eq!(parse_store_major_from_modules_yaml(windows), Some(10));

        // 合法 JSON 但没有 storeDir(或值不是字符串)→ 仍视为未知
        assert_eq!(parse_store_dir_from_modules_yaml("{}"), None);
        assert_eq!(
            parse_store_dir_from_modules_yaml(r#"{"storeDir": 5}"#),
            None
        );
    }

    #[test]
    fn store_base_dir_strips_trailing_pnpm_version_segment() {
        assert_eq!(
            strip_store_version("C:\\Users\\test\\AppData\\Local\\pnpm\\store\\v10"),
            "C:\\Users\\test\\AppData\\Local\\pnpm\\store"
        );
        assert_eq!(
            strip_store_version("/home/test/.local/share/pnpm/store/v11"),
            "/home/test/.local/share/pnpm/store"
        );
        // 含空格/以分隔符结尾的写法
        assert_eq!(
            strip_store_version("/Users/gao/Library/pnpm/store/v10/"),
            "/Users/gao/Library/pnpm/store"
        );
        assert_eq!(
            strip_store_version("D:\\.pnpm-store\\v3"),
            "D:\\.pnpm-store"
        );
    }

    #[test]
    fn store_base_dir_keeps_paths_without_version_segment() {
        // 末尾不是 v<数字>:原样返回,避免把用户自定的 store 目录名吃掉
        assert_eq!(
            strip_store_version("C:\\Users\\x\\pnpm\\store"),
            "C:\\Users\\x\\pnpm\\store"
        );
        assert_eq!(
            strip_store_version("/mnt/pnpm-store-v10"),
            "/mnt/pnpm-store-v10"
        );
        assert_eq!(strip_store_version("/mnt/v-store"), "/mnt/v-store");
        assert_eq!(strip_store_version("v10"), "v10");
        assert_eq!(strip_store_version(""), "");
    }

    /// 探测 PATH 必须与 `build_plugin_envs`(安装子进程)同序:桌面端 shim 目录在
    /// 首位,然后才是选定 Node 与用户 pnpm 所在目录。顺序不一致时探测与安装可能
    /// 解析到不同的 pnpm,`ensure_pnpm` 据探测结果选出的主版本与实际安装的不相符。
    #[test]
    fn probe_path_puts_desktop_shim_dir_first() {
        let path = pnpm_probe_path(
            Path::new("/user/bin/pnpm"),
            Some(Path::new("/opt/node/bin/node")),
            Some(Path::new("/desktop/bin")),
        )
        .unwrap();
        let entries: Vec<String> = std::env::split_paths(&path)
            .map(|entry| entry.to_string_lossy().into_owned())
            .collect();
        assert_eq!(entries[0], "/desktop/bin");
        assert_eq!(entries[1], "/opt/node/bin");
        assert_eq!(entries[2], "/user/bin");
    }

    /// 不注入桌面 shim 目录(按精确路径探测)时保持原有顺序,不凭空插入空目录。
    #[test]
    fn probe_path_without_bin_dir_keeps_node_first() {
        let path = pnpm_probe_path(
            Path::new("/user/bin/pnpm"),
            Some(Path::new("/opt/node/bin/node")),
            None,
        )
        .unwrap();
        let entries: Vec<String> = std::env::split_paths(&path)
            .map(|entry| entry.to_string_lossy().into_owned())
            .collect();
        assert_eq!(entries[0], "/opt/node/bin");
        assert_eq!(entries[1], "/user/bin");
    }
}