aube 2.2.0

Aube — a fast Node.js package manager
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
123

//! Stubs for npm-only commands that pnpm claims at the CLI surface.
//!
//! pnpm doesn't implement `whoami`, `token`, `owner`, `search`, `pkg`, or
//! `set-script` — it parses the command name, prints a "not implemented,
//! use npm" error, and exits non-zero. We match that behavior so these
//! names don't fall through aube's implicit-script runner (`External`),
//! where `aube whoami` would otherwise try to run a `whoami` script from
//! `package.json` and produce a confusing "script not found" error.

use miette::{Context, IntoDiagnostic, miette};

#[derive(Debug, usage_rs::Args)]
pub struct FallbackArgs {
    /// Unused; captured so `aube <cmd> foo bar` parses instead of
    /// erroring on unexpected args before the fallback message prints.
    #[usage(arg, double_dash = "automatic", hide)]
    pub args: Vec<String>,
    #[usage(flatten)]
    pub network: crate::cli_args::NetworkArgs,
}

macro_rules! fallback_alias_args {
    ($($name:ident),+ $(,)?) => {
        $(
            #[derive(Debug, usage_rs::Args)]
            pub struct $name {
                #[usage(flatten)]
                pub inner: FallbackArgs,
            }

            impl std::ops::Deref for $name {
                type Target = FallbackArgs;

                fn deref(&self) -> &Self::Target {
                    &self.inner
                }
            }
        )+
    };
}

fallback_alias_args!(
    OwnerArgs,
    PkgArgs,
    SearchArgs,
    SetScriptArgs,
    StageArgs,
    TokenArgs,
    WhoamiArgs,
);

pub fn run(name: &str, args: &FallbackArgs) -> miette::Result<i32> {
    args.network.install_overrides();
    let cwd = crate::dirs::cwd()?;
    let files = crate::commands::FileSources::load(&cwd);
    let empty_ws = std::collections::BTreeMap::new();
    let env = aube_settings::values::process_env();
    let ctx = files.ctx(&empty_ws, env, &[]);

    if let Some(npm_path) = aube_settings::resolved::npm_path(&ctx) {
        let mut cmd = std::process::Command::new(&npm_path);
        cmd.arg(name)
            .args(&args.args)
            .stderr(aube_scripts::child_stderr());
        if let Some(registry) = args.network.registry.as_deref() {
            cmd.arg(format!("--registry={registry}"));
        }
        let status = cmd
            .status()
            .into_diagnostic()
            .wrap_err_with(|| format!("failed to run configured npmPath `{npm_path}`"))?;
        return Ok(child_exit_code(status));
    }

    Err(miette!(
        code = aube_codes::errors::ERR_AUBE_NPM_ONLY_COMMAND,
        "`aube {name}` is not implemented. This is an npm-only command — \
         run it with `npm {name}` instead, or set `npmPath` to let aube delegate it."
    ))
}

fn child_exit_code(status: std::process::ExitStatus) -> i32 {
    if let Some(code) = status.code() {
        return code;
    }

    #[cfg(unix)]
    {
        use std::os::unix::process::ExitStatusExt;

        if let Some(signal) = status.signal() {
            return 128 + signal;
        }
    }

    1
}

#[cfg(test)]
mod tests {
    #[cfg(unix)]
    use super::child_exit_code;

    #[cfg(unix)]
    #[test]
    fn child_signal_exit_uses_shell_convention() {
        use std::os::unix::process::ExitStatusExt;

        let status = std::process::ExitStatus::from_raw(2);

        assert_eq!(child_exit_code(status), 130);
    }

    #[cfg(unix)]
    #[test]
    fn child_normal_exit_code_is_preserved() {
        use std::os::unix::process::ExitStatusExt;

        let status = std::process::ExitStatus::from_raw(7 << 8);

        assert_eq!(child_exit_code(status), 7);
    }
}