Merge branch 'main' into feat/task-command-shorthands

Author: jong-kyung

crates/vite_task/src/lib.rs

@@ -4,7 +4,9 @@ pub mod session;
 
 // Public exports for vite_task_bin
 pub use cli::{CacheSubcommand, Command, RunCommand, RunFlags};
-pub use session::{CommandHandler, ExitStatus, HandledCommand, Session, SessionConfig};
+pub use session::{
+    CommandHandler, ExitStatus, HandledCommand, Session, SessionConfig, print_error,
+};
 pub use vite_task_graph::{
     config::{
         self,

crates/vite_task/src/session/mod.rs

@@ -244,15 +244,19 @@ impl<'a> Session<'a> {
 
     /// Primary entry point for CLI usage. Plans and executes the given command.
     ///
-    /// # Errors
-    ///
-    /// Returns an error if planning or execution fails.
+    /// Any error encountered during planning or execution is printed to stderr
+    /// with a bold red `error:` prefix, with each level of the error chain on
+    /// its own `* `-prefixed line. Returns the exit status — callers exit the
+    /// process with it.
     #[tracing::instrument(level = "debug", skip_all)]
-    pub async fn main(mut self, command: Command) -> anyhow::Result<ExitStatus> {
+    pub async fn main(mut self, command: Command) -> ExitStatus {
         match self.main_inner(command).await {
-            Ok(()) => Ok(ExitStatus::SUCCESS),
-            Err(SessionError::EarlyExit(status)) => Ok(status),
-            Err(SessionError::Anyhow(err)) => Err(err),
+            Ok(()) => ExitStatus::SUCCESS,
+            Err(SessionError::EarlyExit(status)) => status,
+            Err(SessionError::Anyhow(err)) => {
+                print_error(&err);
+                ExitStatus::FAILURE
+            }
         }
     }
 
@@ -795,6 +799,29 @@ impl<'a> Session<'a> {
     }
 }
 
+/// Print `error` to stderr formatted as the `vp` CLI does:
+///
+/// ```text
+/// error: <top-level message>
+/// * <source>
+/// * <source.source()>
+/// ```
+///
+/// The `error:` prefix is bold red when stderr supports ANSI colors.
+pub fn print_error(error: &anyhow::Error) {
+    use std::io::Write as _;
+
+    use owo_colors::{OwoColorize as _, Stream, Style};
+
+    let prefix = "error:".if_supports_color(Stream::Stderr, |s| s.style(Style::new().red().bold()));
+    let mut stderr = std::io::stderr().lock();
+    let _ = write!(stderr, "{prefix} {error}");
+    for source in error.chain().skip(1) {
+        let _ = write!(stderr, "\n* {source}");
+    }
+    let _ = writeln!(stderr);
+}
+
 /// Whether stdout supports ANSI color output for the current process. Honors
 /// `NO_COLOR`/`FORCE_COLOR` and detects TTY capability via the `supports-color`
 /// crate. Result is cached for the process lifetime.

crates/vite_task_bin/src/main.rs

@@ -3,24 +3,21 @@ use vite_task::{Command, ExitStatus, Session};
 use vite_task_bin::OwnedSessionConfig;
 
 fn main() -> ! {
-    let exit_code: i32 =
-        tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
-            match run().await {
-                Ok(status) => i32::from(status.0),
-                #[expect(clippy::print_stderr, reason = "top-level error reporting")]
-                Err(err) => {
-                    eprintln!("Error: {err:?}");
-                    1
-                }
-            }
-        });
+    let status: ExitStatus =
+        tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(run());
 
-    std::process::exit(exit_code);
+    std::process::exit(i32::from(status.0));
 }
 
-async fn run() -> anyhow::Result<ExitStatus> {
+async fn run() -> ExitStatus {
     let args = Command::parse();
     let mut owned_config = OwnedSessionConfig::default();
-    let session = Session::init(owned_config.as_config())?;
+    let session = match Session::init(owned_config.as_config()) {
+        Ok(session) => session,
+        Err(err) => {
+            vite_task::print_error(&err);
+            return ExitStatus::FAILURE;
+        }
+    };
     session.main(args).await
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/error_cycle_dependency/snapshots/cycle_dependency_error.md

@@ -9,5 +9,5 @@ task-a -> task-b -> task-a cycle
 **Exit code:** 1
 
 ```
-Error: Cycle dependency detected: error-cycle-dependency-test#task-a -> error-cycle-dependency-test#task-b -> error-cycle-dependency-test#task-a
+error: Cycle dependency detected: error-cycle-dependency-test#task-a -> error-cycle-dependency-test#task-b -> error-cycle-dependency-test#task-a
 ```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/a.mjs

@@ -0,0 +1 @@
+export const value = 'a';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/b.mjs

@@ -0,0 +1 @@
+export const value = 'b';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/c.mjs

@@ -0,0 +1 @@
+export const value = 'c';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "node-compile-cache-outside-workspace-fixture",
+  "private": true,
+  "type": "module"
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/run.mjs

@@ -0,0 +1,20 @@
+// Tiny Node script that turns on the v22 compile cache and imports a
+// few sibling modules so the cache directory actually gets some files
+// written to it. On a normally-configured machine the cache lives in
+// the OS temp directory (outside the workspace), so the runner doesn't
+// see those files when it decides whether the run can be cached.
+//
+// If the spawned process doesn't have LOCALAPPDATA (or TMP/TEMP/
+// USERPROFILE) set on Windows, Node ends up putting the cache inside
+// the workspace, the same files are both written and read in this one
+// run, and the runner refuses to cache it. That's the bug this fixture
+// catches.
+import { enableCompileCache } from 'node:module';
+
+enableCompileCache();
+
+await import('./a.mjs');
+await import('./b.mjs');
+await import('./c.mjs');
+
+console.log('done');

crates/vite_task_bin/tests/e2e_snapshots/fixtures/node_compile_cache_outside_workspace/snapshots.toml

@@ -0,0 +1,20 @@
+[[e2e]]
+name = "node_compile_cache_does_not_poison_workspace"
+comment = """
+Runs a small Node script that turns on Node's compile cache. The cache should land in the OS temp directory (outside the workspace), so two `vt run --cache build` calls should be a miss then a hit. On Windows, if the spawned task env doesn't have `LOCALAPPDATA`, Node puts the cache inside the workspace instead, the runner sees the same files both written and read, and refuses to cache the run — so the second call becomes another miss with a "not cached because it modified its input" message.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "--cache",
+    "build",
+  ], comment = "first run: cache miss" },
+  { argv = [
+    "vt",
+    "run",
+    "--cache",
+    "build",
+  ], comment = "second run: cache hit" },
+]