hni 0.0.3

ni-compatible package manager command router with node shim
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use std::{
    env,
    path::{Path, PathBuf},
    process::Command,
};

use anyhow::Result;

use crate::{
    core::types::{NativeLocalBinExecution, NativeScriptExecution, PackageManager},
    platform::node::{REAL_NODE_ENV, resolve_real_node_path},
};

pub(super) fn native_script_env(
    exec: &NativeScriptExecution,
    invocation_cwd: &std::path::Path,
) -> Result<Vec<(String, String)>> {
    let mut envs = Vec::with_capacity(7);
    envs.push((
        "INIT_CWD".to_string(),
        invocation_cwd.to_string_lossy().to_string(),
    ));
    envs.push((
        "npm_package_json".to_string(),
        exec.package_json_path.to_string_lossy().to_string(),
    ));

    if let Ok(current_exe) = env::current_exe() {
        envs.push((
            "npm_execpath".to_string(),
            current_exe.to_string_lossy().to_string(),
        ));
    }

    if let Ok(real_node) = resolve_real_node_path() {
        envs.push((
            "npm_node_execpath".to_string(),
            real_node.to_string_lossy().to_string(),
        ));
    }

    envs.push(("npm_command".to_string(), "run-script".to_string()));

    if let Ok(user_agent) = env::var("npm_config_user_agent") {
        envs.push(("npm_config_user_agent".to_string(), user_agent));
    }

    let merged_path = merged_path_with_bins(&exec.bin_paths)?;
    envs.push(("PATH".to_string(), merged_path));
    Ok(envs)
}

pub(super) fn apply_local_bin_environment(
    command: &mut Command,
    exec: &NativeLocalBinExecution,
    invocation_cwd: &Path,
) -> Result<()> {
    if let Ok(path) = merged_path_with_bins(&exec.bin_paths) {
        command.env("PATH", path);
    }

    if let Ok(real_node) = resolve_real_node_path() {
        command.env(REAL_NODE_ENV, &real_node);
        command.env("npm_node_execpath", real_node);
    }

    command.env("INIT_CWD", invocation_cwd);
    command.env("npm_command", "exec");
    command.env(
        "npm_execpath",
        package_manager_execpath(exec.package_manager),
    );

    if let Ok(user_agent) = env::var("npm_config_user_agent") {
        command.env("npm_config_user_agent", user_agent);
    } else {
        command.env(
            "npm_config_user_agent",
            synthetic_user_agent(exec.package_manager),
        );
    }

    Ok(())
}

pub(super) fn merged_path_with_bins(bin_paths: &[PathBuf]) -> Result<String> {
    let current_path = env::var_os("PATH");
    let mut ordered = bin_paths.to_vec();

    if let Ok(real_node) = resolve_real_node_path()
        && let Some(real_node_dir) = real_node.parent()
    {
        ordered.push(real_node_dir.to_path_buf());
        if let Some(current_path) = current_path {
            ordered.extend(env::split_paths(&current_path).filter(|entry| entry != real_node_dir));
        }
        return join_paths_string(ordered);
    }

    if let Some(current_path) = current_path {
        ordered.extend(env::split_paths(&current_path));
    }

    join_paths_string(ordered)
}

fn join_paths_string(paths: Vec<PathBuf>) -> Result<String> {
    env::join_paths(paths)
        .map(|value| value.to_string_lossy().to_string())
        .map_err(Into::into)
}

fn package_manager_execpath(pm: PackageManager) -> String {
    which::which(pm.bin())
        .unwrap_or_else(|_| PathBuf::from(pm.bin()))
        .to_string_lossy()
        .to_string()
}

fn synthetic_user_agent(pm: PackageManager) -> String {
    format!("{}/0.0.0 hni/fast", pm.bin())
}