npm_run_scripts/runner/
executor.rs

1//! Script execution.
2//!
3//! Handles running scripts with the appropriate package manager,
4//! including single script execution, batch execution, and dry-run mode.
5
6use std::io::{self, Write};
7use std::path::Path;
8use std::process::{Command, ExitStatus};
9
10use anyhow::{Context, Result};
11
12use crate::package::{Runner, Script};
13
14/// Exit code when interrupted by Ctrl+C (SIGINT).
15/// On Unix, this is 128 + signal number (SIGINT = 2).
16pub const EXIT_CODE_INTERRUPTED: i32 = 130;
17
18/// Result of script execution.
19#[derive(Debug)]
20pub struct ExecutionResult {
21    /// Exit status of the script.
22    pub status: ExitStatus,
23    /// The command that was executed.
24    pub command: String,
25}
26
27impl ExecutionResult {
28    /// Check if the execution was successful.
29    pub fn success(&self) -> bool {
30        self.status.success()
31    }
32
33    /// Get the exit code.
34    pub fn code(&self) -> Option<i32> {
35        self.status.code()
36    }
37}
38
39/// Run a single script with the given runner.
40///
41/// # Arguments
42///
43/// * `runner` - The package manager to use
44/// * `script` - The script to run
45/// * `args` - Optional additional arguments to pass to the script
46/// * `dry_run` - If true, print the command without executing
47///
48/// # Returns
49///
50/// Returns the exit code of the script (0 for success, non-zero for failure).
51/// Returns 130 if interrupted by Ctrl+C.
52///
53/// # Errors
54///
55/// Returns an error if the script fails to spawn.
56pub fn run_script(
57    runner: Runner,
58    script: &Script,
59    args: Option<&str>,
60    dry_run: bool,
61) -> Result<i32> {
62    let args_vec: Vec<String> = args
63        .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
64        .unwrap_or_default();
65
66    let project_dir = std::env::current_dir().context("Failed to get current directory")?;
67
68    execute_script(runner, script.name(), &args_vec, &project_dir, dry_run)
69        .map(|result| result.code().unwrap_or(EXIT_CODE_INTERRUPTED))
70}
71
72/// Run a single script in a specific directory.
73///
74/// # Arguments
75///
76/// * `runner` - The package manager to use
77/// * `script` - The script to run
78/// * `args` - Optional additional arguments to pass to the script
79/// * `project_dir` - The project directory to run in
80/// * `dry_run` - If true, print the command without executing
81///
82/// # Returns
83///
84/// Returns the exit code of the script (0 for success, non-zero for failure).
85/// Returns 130 if interrupted by Ctrl+C.
86///
87/// # Errors
88///
89/// Returns an error if the script fails to spawn.
90pub fn run_script_in_dir(
91    runner: Runner,
92    script: &Script,
93    args: Option<&str>,
94    project_dir: &Path,
95    dry_run: bool,
96) -> Result<i32> {
97    let args_vec: Vec<String> = args
98        .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
99        .unwrap_or_default();
100
101    execute_script(runner, script.name(), &args_vec, project_dir, dry_run)
102        .map(|result| result.code().unwrap_or(EXIT_CODE_INTERRUPTED))
103}
104
105/// Run multiple scripts sequentially.
106///
107/// Scripts are run in order. Execution stops on the first failure.
108/// Progress is printed to stdout: "Running 1/3: dev..."
109///
110/// # Arguments
111///
112/// * `runner` - The package manager to use
113/// * `scripts` - Scripts to run with their optional arguments
114/// * `dry_run` - If true, print the commands without executing
115///
116/// # Returns
117///
118/// Returns a vector of exit codes for each script that was executed.
119/// If a script fails, the vector will contain exit codes up to and including
120/// the failed script.
121///
122/// # Errors
123///
124/// Returns an error if any script fails to spawn.
125pub fn run_scripts(
126    runner: Runner,
127    scripts: &[(&Script, Option<String>)],
128    dry_run: bool,
129) -> Result<Vec<i32>> {
130    let total = scripts.len();
131    let mut results = Vec::with_capacity(total);
132    let project_dir = std::env::current_dir().context("Failed to get current directory")?;
133
134    for (i, (script, args)) in scripts.iter().enumerate() {
135        // Print progress
136        println!(
137            "\n\x1b[1;36mRunning {}/{}: {}...\x1b[0m",
138            i + 1,
139            total,
140            script.name()
141        );
142        io::stdout().flush().ok();
143
144        let args_vec: Vec<String> = args
145            .as_ref()
146            .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
147            .unwrap_or_default();
148
149        let result = execute_script(runner, script.name(), &args_vec, &project_dir, dry_run)?;
150        let exit_code = result.code().unwrap_or(EXIT_CODE_INTERRUPTED);
151        results.push(exit_code);
152
153        // Stop on first failure (non-zero exit code)
154        if exit_code != 0 {
155            println!(
156                "\n\x1b[1;31mScript '{}' failed with exit code {}\x1b[0m",
157                script.name(),
158                exit_code
159            );
160            break;
161        }
162    }
163
164    Ok(results)
165}
166
167/// Run multiple scripts sequentially in a specific directory.
168///
169/// Scripts are run in order. Execution stops on the first failure.
170/// Progress is printed to stdout: "Running 1/3: dev..."
171///
172/// # Arguments
173///
174/// * `runner` - The package manager to use
175/// * `scripts` - Scripts to run with their optional arguments
176/// * `project_dir` - The project directory to run in
177/// * `dry_run` - If true, print the commands without executing
178///
179/// # Returns
180///
181/// Returns a vector of exit codes for each script that was executed.
182/// If a script fails, the vector will contain exit codes up to and including
183/// the failed script.
184///
185/// # Errors
186///
187/// Returns an error if any script fails to spawn.
188pub fn run_scripts_in_dir(
189    runner: Runner,
190    scripts: &[(&Script, Option<String>)],
191    project_dir: &Path,
192    dry_run: bool,
193) -> Result<Vec<i32>> {
194    let total = scripts.len();
195    let mut results = Vec::with_capacity(total);
196
197    for (i, (script, args)) in scripts.iter().enumerate() {
198        // Print progress
199        println!(
200            "\n\x1b[1;36mRunning {}/{}: {}...\x1b[0m",
201            i + 1,
202            total,
203            script.name()
204        );
205        io::stdout().flush().ok();
206
207        let args_vec: Vec<String> = args
208            .as_ref()
209            .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
210            .unwrap_or_default();
211
212        let result = execute_script(runner, script.name(), &args_vec, project_dir, dry_run)?;
213        let exit_code = result.code().unwrap_or(EXIT_CODE_INTERRUPTED);
214        results.push(exit_code);
215
216        // Stop on first failure (non-zero exit code)
217        if exit_code != 0 {
218            println!(
219                "\n\x1b[1;31mScript '{}' failed with exit code {}\x1b[0m",
220                script.name(),
221                exit_code
222            );
223            break;
224        }
225    }
226
227    Ok(results)
228}
229
230/// Execute a script with the given runner.
231///
232/// This is the low-level execution function that spawns the process.
233///
234/// # Arguments
235///
236/// * `runner` - The package manager to use
237/// * `script` - The script name to run
238/// * `args` - Additional arguments to pass to the script
239/// * `project_dir` - The project directory to run in
240/// * `dry_run` - If true, print the command without executing
241///
242/// # Errors
243///
244/// Returns an error if the script fails to execute.
245pub fn execute_script(
246    runner: Runner,
247    script: &str,
248    args: &[String],
249    project_dir: &Path,
250    dry_run: bool,
251) -> Result<ExecutionResult> {
252    let cmd_parts = runner.run_command_with_args(script, args);
253    let command_str = cmd_parts.join(" ");
254
255    if dry_run {
256        println!("Would run: {command_str}");
257        return Ok(ExecutionResult {
258            status: std::process::ExitStatus::default(),
259            command: command_str,
260        });
261    }
262
263    let mut command = Command::new(&cmd_parts[0]);
264    command.args(&cmd_parts[1..]);
265    command.current_dir(project_dir);
266
267    // Inherit stdio for interactive scripts
268    command.stdin(std::process::Stdio::inherit());
269    command.stdout(std::process::Stdio::inherit());
270    command.stderr(std::process::Stdio::inherit());
271
272    let status = command
273        .status()
274        .with_context(|| format!("Failed to execute: {command_str}"))?;
275
276    Ok(ExecutionResult {
277        status,
278        command: command_str,
279    })
280}
281
282/// Format a command for display in dry-run mode.
283pub fn format_dry_run_command(runner: Runner, script: &str, args: Option<&str>) -> String {
284    let args_vec: Vec<String> = args
285        .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
286        .unwrap_or_default();
287
288    let cmd = runner.run_command_with_args(script, &args_vec);
289    format!("Would run: {}", cmd.join(" "))
290}
291
292/// Execute a workspace script with the given runner.
293///
294/// This runs a script in a specific workspace package from the monorepo root.
295///
296/// # Arguments
297///
298/// * `runner` - The package manager to use
299/// * `workspace` - The workspace name (package name)
300/// * `script` - The script name to run
301/// * `args` - Additional arguments to pass to the script
302/// * `project_dir` - The project directory (monorepo root) to run in
303/// * `dry_run` - If true, print the command without executing
304///
305/// # Errors
306///
307/// Returns an error if the script fails to execute.
308pub fn execute_workspace_script(
309    runner: Runner,
310    workspace: &str,
311    script: &str,
312    args: &[String],
313    project_dir: &Path,
314    dry_run: bool,
315) -> Result<ExecutionResult> {
316    let cmd_parts = runner.workspace_command_with_args(workspace, script, args);
317    let command_str = cmd_parts.join(" ");
318
319    if dry_run {
320        println!("Would run: {command_str}");
321        return Ok(ExecutionResult {
322            status: std::process::ExitStatus::default(),
323            command: command_str,
324        });
325    }
326
327    let mut command = Command::new(&cmd_parts[0]);
328    command.args(&cmd_parts[1..]);
329    command.current_dir(project_dir);
330
331    // Inherit stdio for interactive scripts
332    command.stdin(std::process::Stdio::inherit());
333    command.stdout(std::process::Stdio::inherit());
334    command.stderr(std::process::Stdio::inherit());
335
336    let status = command
337        .status()
338        .with_context(|| format!("Failed to execute: {command_str}"))?;
339
340    Ok(ExecutionResult {
341        status,
342        command: command_str,
343    })
344}
345
346/// Run a workspace script.
347///
348/// # Arguments
349///
350/// * `runner` - The package manager to use
351/// * `workspace` - The workspace name (package name)
352/// * `script` - The script to run
353/// * `args` - Optional additional arguments to pass to the script
354/// * `project_dir` - The project directory (monorepo root) to run in
355/// * `dry_run` - If true, print the command without executing
356///
357/// # Returns
358///
359/// Returns the exit code of the script (0 for success, non-zero for failure).
360pub fn run_workspace_script(
361    runner: Runner,
362    workspace: &str,
363    script: &Script,
364    args: Option<&str>,
365    project_dir: &Path,
366    dry_run: bool,
367) -> Result<i32> {
368    let args_vec: Vec<String> = args
369        .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
370        .unwrap_or_default();
371
372    execute_workspace_script(
373        runner,
374        workspace,
375        script.name(),
376        &args_vec,
377        project_dir,
378        dry_run,
379    )
380    .map(|result| result.code().unwrap_or(EXIT_CODE_INTERRUPTED))
381}
382
383/// Format a workspace command for display in dry-run mode.
384pub fn format_workspace_dry_run_command(
385    runner: Runner,
386    workspace: &str,
387    script: &str,
388    args: Option<&str>,
389) -> String {
390    let args_vec: Vec<String> = args
391        .map(|a| shell_words::split(a).unwrap_or_else(|_| vec![a.to_string()]))
392        .unwrap_or_default();
393
394    let cmd = runner.workspace_command_with_args(workspace, script, &args_vec);
395    format!("Would run: {}", cmd.join(" "))
396}
397
398#[cfg(test)]
399mod tests {
400    use super::*;
401
402    #[test]
403    fn test_dry_run() {
404        let result = execute_script(Runner::Npm, "test", &[], Path::new("."), true).unwrap();
405
406        assert_eq!(result.command, "npm run test");
407    }
408
409    #[test]
410    fn test_dry_run_with_args() {
411        let args = vec!["--watch".to_string(), "--coverage".to_string()];
412        let result = execute_script(Runner::Npm, "test", &args, Path::new("."), true).unwrap();
413
414        assert_eq!(result.command, "npm run test -- --watch --coverage");
415    }
416
417    #[test]
418    fn test_format_dry_run_command() {
419        assert_eq!(
420            format_dry_run_command(Runner::Npm, "dev", None),
421            "Would run: npm run dev"
422        );
423
424        assert_eq!(
425            format_dry_run_command(Runner::Npm, "dev", Some("--host")),
426            "Would run: npm run dev -- --host"
427        );
428
429        assert_eq!(
430            format_dry_run_command(Runner::Yarn, "dev", Some("--host")),
431            "Would run: yarn dev --host"
432        );
433
434        assert_eq!(
435            format_dry_run_command(Runner::Pnpm, "dev", Some("--host")),
436            "Would run: pnpm dev -- --host"
437        );
438
439        assert_eq!(
440            format_dry_run_command(Runner::Bun, "dev", Some("--host")),
441            "Would run: bun run dev --host"
442        );
443    }
444
445    #[test]
446    fn test_run_script_dry_run() {
447        let script = Script::new("dev", "vite");
448        let result = run_script(Runner::Npm, &script, None, true).unwrap();
449        assert_eq!(result, 0);
450    }
451
452    #[test]
453    fn test_run_script_with_args_dry_run() {
454        let script = Script::new("dev", "vite");
455        let result = run_script(Runner::Npm, &script, Some("--host"), true).unwrap();
456        assert_eq!(result, 0);
457    }
458
459    #[test]
460    fn test_run_scripts_dry_run() {
461        let script1 = Script::new("build", "vite build");
462        let script2 = Script::new("test", "vitest");
463        let scripts: Vec<(&Script, Option<String>)> =
464            vec![(&script1, None), (&script2, Some("--coverage".to_string()))];
465
466        let results = run_scripts(Runner::Npm, &scripts, true).unwrap();
467        assert_eq!(results, vec![0, 0]);
468    }
469}
npm_run_scripts/runner/executor.rs

npm_run_scripts/runner/
executor.rs
