feat(cache): store colored task logs, strip at display when needed (#378)

Fixes #358.

## Summary

- Cached tasks are spawned with `FORCE_COLOR=1`, so the cache always
stores task logs with ANSI colors intact. On a cache hit the original
bytes are replayed verbatim — cached logs keep their colors regardless
of the parent's `FORCE_COLOR` value.
- Colors are stripped at display time when the user's terminal does not
support them, decided per stdout/stderr via the `supports-color` crate.
- `NO_COLOR`, `COLORTERM`, `TERM`, and `TERM_PROGRAM` are no longer in
`DEFAULT_UNTRACKED_ENV`. Tasks that need them can opt in via `env` /
`untrackedEnv`.

## Implementation notes

- `EnvFingerprints::resolve` pre-inserts `FORCE_COLOR=1` before pattern
filtering. `FORCE_COLOR` stays in `DEFAULT_UNTRACKED_ENV`, so the value
is passed through but not part of the cache key.
- A new `ColorSupport { stdout, stderr }` struct threads per-stream
support through the reporter builders. `maybe_strip_writer` is applied
only to the `StdioConfig.writers` returned from
`LeafExecutionReporter::start` (child stdout/stderr and the grouped
buffer); banners and summaries use a thin `ColorizeExt::style` extension
that delegates to `OwoColorize::if_supports_color`.
- e2e harness gained `formatted-snapshot = true` (per-step) and switched
`screen_contents_formatted` to `vt100::Screen::rows_formatted`. Raw
`\x1b[m` resets are stripped from the rendered rows so snapshots match
across Linux/macOS/Windows ConPTY.

## Test plan

- [x] `cargo test -p vite_task -p vite_task_plan -p vite_task_graph`
- [x] `cargo test -p vite_task_bin --test e2e_snapshots`
- [x] `cargo clippy --tests` on Linux
- [x] `cargo doc --workspace -D warnings`
- [ ] CI passes on all platforms (Linux gnu, musl, macOS x86_64/arm64,
Windows)

https://claude.ai/code/session_01EAhpw6TzUWExMeF7hdwuF3

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Changed** Cached logs are stored with colors intact (`FORCE_COLOR=1` is auto-injected into spawned tasks). Colors are then stripped at display time when the terminal does not support them. Other color-related env vars (`NO_COLOR`, `COLORTERM`, `TERM`, `TERM_PROGRAM`) are no longer passed through by default. Opt in via a task's `env`/`untrackedEnv` ([#378](https://github.com/voidzero-dev/vite-task/pull/378))
 - **Added** `output` field for cached tasks: archives matching files after a successful run and restores them on cache hit ([#375](https://github.com/voidzero-dev/vite-task/pull/375))
 - **Fixed** Windows cached tasks can now run package shims rewritten through PowerShell; default env passthrough now preserves `PATHEXT` ([#366](https://github.com/voidzero-dev/vite-task/pull/366))
 - **Added** Platform support for targets without `input` auto-inference (e.g. Android). Tasks still run; those relying on auto-inference run uncached, with the summary noting that `input` must be configured manually to enable caching ([#352](https://github.com/voidzero-dev/vite-task/pull/352))

Cargo.lock

@@ -40,6 +40,7 @@ future_not_send = "allow"
 
 [workspace.dependencies]
 allocator-api2 = { version = "0.2.21", default-features = false, features = ["alloc", "std"] }
+anstream = "0.6.21"
 anyhow = "1.0.98"
 assert2 = "0.4.0"
 assertables = "9.8.1"

Cargo.toml

@@ -128,6 +128,53 @@ impl PtyReader {
         self.parser.lock().unwrap().screen().contents()
     }
 
+    /// Returns the screen contents row-by-row with inline ANSI SGR escapes
+    /// preserved — useful for snapshot tests that need to assert colour/style.
+    ///
+    /// Rows are produced via [`vt100::Screen::rows_formatted`], which emits
+    /// only the SGR attribute escapes (no cursor positioning, no
+    /// screen-erase sequences), so the output is platform-stable. Trailing
+    /// fully-empty rows are dropped; remaining rows are joined with `\n`.
+    ///
+    /// Bare SGR-reset sequences (`\x1b[m`) are also stripped: Unix PTYs emit
+    /// them between styled spans and at the end of styled runs, but Windows
+    /// `ConPTY` consolidates the byte stream and elides those resets. Stripping
+    /// them produces identical output on all platforms while preserving the
+    /// non-reset SGR transitions that the test actually cares about.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the parser lock is poisoned.
+    #[expect(
+        clippy::significant_drop_tightening,
+        reason = "vt100::Screen::rows_formatted yields borrowed iterators that need the guard alive"
+    )]
+    #[must_use]
+    pub fn screen_contents_formatted(&self) -> Vec<u8> {
+        const RESET: &[u8] = b"\x1b[m";
+        let guard = self.parser.lock().unwrap();
+        let screen = guard.screen();
+        let cols = screen.size().1;
+        let rows: Vec<Vec<u8>> = screen
+            .rows_formatted(0, cols)
+            .map(|mut row| {
+                while let Some(idx) = row.windows(RESET.len()).position(|w| w == RESET) {
+                    row.drain(idx..idx + RESET.len());
+                }
+                row
+            })
+            .collect();
+        let last_non_empty = rows.iter().rposition(|r| !r.is_empty()).map_or(0, |i| i + 1);
+        let mut out = Vec::new();
+        for (i, row) in rows[..last_non_empty].iter().enumerate() {
+            if i > 0 {
+                out.push(b'\n');
+            }
+            out.extend_from_slice(row);
+        }
+        out
+    }
+
     /// Drains and returns all unhandled OSC sequences received since the last call.
     ///
     /// Each entry is a list of byte-vector parameters from a single OSC sequence

crates/pty_terminal/src/terminal.rs

@@ -52,6 +52,13 @@ impl Reader {
         contents
     }
 
+    /// Returns the screen contents with inline ANSI SGR escape codes preserved.
+    /// Useful for snapshot tests that need to assert colour or style attributes.
+    #[must_use]
+    pub fn screen_contents_formatted(&self) -> Vec<u8> {
+        self.pty.get_ref().screen_contents_formatted()
+    }
+
     /// Reads from the PTY until a milestone with the given name is encountered.
     ///
     /// Returns the terminal screen contents at the moment the milestone is detected.

crates/pty_terminal_test/src/lib.rs

@@ -12,6 +12,7 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
+anstream = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 wincode = { workspace = true, features = ["derive"] }
@@ -28,6 +29,7 @@ rusqlite = { workspace = true, features = ["bundled"] }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive", "rc"] }
 serde_json = { workspace = true }
+supports-color = { workspace = true }
 thiserror = { workspace = true }
 tar = { workspace = true }
 tokio = { workspace = true, features = [

crates/vite_task/Cargo.toml

@@ -12,7 +12,7 @@ use clap::Parser as _;
 use once_cell::sync::OnceCell;
 pub use reporter::ExitStatus;
 use reporter::{
-    GroupedReporterBuilder, InterleavedReporterBuilder, LabeledReporterBuilder,
+    ColorSupport, GroupedReporterBuilder, InterleavedReporterBuilder, LabeledReporterBuilder,
     SummaryReporterBuilder,
     summary::{LastRunSummary, ReadSummaryError, format_full_summary},
 };
@@ -313,20 +313,36 @@ impl<'a> Session<'a> {
                 let workspace_path = self.workspace_path();
                 let writer: Box<dyn std::io::Write> = Box::new(std::io::stdout());
 
-                let inner: Box<dyn reporter::GraphExecutionReporterBuilder> =
-                    match run_command.flags.log {
-                        crate::cli::LogMode::Interleaved => Box::new(
-                            InterleavedReporterBuilder::new(Arc::clone(&workspace_path), writer),
-                        ),
-                        crate::cli::LogMode::Labeled => Box::new(LabeledReporterBuilder::new(
-                            Arc::clone(&workspace_path),
-                            writer,
-                        )),
-                        crate::cli::LogMode::Grouped => Box::new(GroupedReporterBuilder::new(
-                            Arc::clone(&workspace_path),
-                            writer,
-                        )),
-                    };
+                // Detect color support once at the point where reporters are
+                // constructed. The reporters and their pipe writers then strip
+                // ANSI escapes from cached/replayed output if the terminal
+                // can't render them. Detect per-stream so a redirected stdout
+                // doesn't trigger stripping of an interactive stderr.
+                let color_support = ColorSupport {
+                    stdout: stdout_supports_color(),
+                    stderr: stderr_supports_color(),
+                };
+
+                let inner: Box<dyn reporter::GraphExecutionReporterBuilder> = match run_command
+                    .flags
+                    .log
+                {
+                    crate::cli::LogMode::Interleaved => Box::new(InterleavedReporterBuilder::new(
+                        Arc::clone(&workspace_path),
+                        writer,
+                        color_support,
+                    )),
+                    crate::cli::LogMode::Labeled => Box::new(LabeledReporterBuilder::new(
+                        Arc::clone(&workspace_path),
+                        writer,
+                        color_support,
+                    )),
+                    crate::cli::LogMode::Grouped => Box::new(GroupedReporterBuilder::new(
+                        Arc::clone(&workspace_path),
+                        writer,
+                        color_support,
+                    )),
+                };
 
                 let builder = Box::new(SummaryReporterBuilder::new(
                     inner,
@@ -335,6 +351,7 @@ impl<'a> Session<'a> {
                     run_command.flags.verbose,
                     Some(self.make_summary_writer()),
                     self.program_name.clone(),
+                    color_support,
                 ));
                 // Don't let SIGINT/CTRL_C kill the runner. Child tasks receive
                 // the signal directly from the terminal driver and handle it
@@ -590,6 +607,10 @@ impl<'a> Session<'a> {
         let path = self.summary_file_path();
         match LastRunSummary::read_from_path(&path) {
             Ok(Some(summary)) => {
+                // `format_full_summary` decides colour vs plain text per
+                // styled span via `ColorizeExt` (which consults
+                // `supports-color`), so the buffer already matches the
+                // terminal's capability and we write it to stdout directly.
                 let buf = format_full_summary(&summary);
                 {
                     use std::io::Write;
@@ -668,8 +689,11 @@ impl<'a> Session<'a> {
         let cache = self.cache()?;
 
         // Create a plain (standalone) reporter — no graph awareness, no summary
-        let plain_reporter =
-            reporter::PlainReporter::new(silent_if_cache_hit, Box::new(std::io::stdout()));
+        let plain_reporter = reporter::PlainReporter::new(
+            silent_if_cache_hit,
+            Box::new(std::io::stdout()),
+            ColorSupport { stdout: stdout_supports_color(), stderr: stderr_supports_color() },
+        );
 
         // Execute the spawn directly using the free function, bypassing the graph pipeline
         let outcome = execute::execute_spawn(
@@ -770,3 +794,21 @@ impl<'a> Session<'a> {
         .await
     }
 }
+
+/// 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.
+fn stdout_supports_color() -> bool {
+    use std::sync::OnceLock;
+    static CACHE: OnceLock<bool> = OnceLock::new();
+    *CACHE.get_or_init(|| supports_color::on(supports_color::Stream::Stdout).is_some())
+}
+
+/// Whether stderr supports ANSI color output. Detected independently from
+/// stdout so a redirected stdout (non-TTY) does not strip ANSI from a stderr
+/// that is still an interactive terminal.
+fn stderr_supports_color() -> bool {
+    use std::sync::OnceLock;
+    static CACHE: OnceLock<bool> = OnceLock::new();
+    *CACHE.get_or_init(|| supports_color::on(supports_color::Stream::Stderr).is_some())
+}

crates/vite_task/src/session/mod.rs

@@ -7,9 +7,10 @@ use vite_path::AbsolutePath;
 use vite_task_plan::{ExecutionItemDisplay, LeafExecutionKind};
 
 use super::{
-    ColorizeExt, ExitStatus, GraphExecutionReporter, GraphExecutionReporterBuilder,
+    ColorSupport, ColorizeExt, ExitStatus, GraphExecutionReporter, GraphExecutionReporterBuilder,
     LeafExecutionReporter, PipeWriters, StdioConfig, StdioSuggestion,
-    format_command_with_cache_status, format_task_label, write_leaf_trailing_output,
+    format_command_with_cache_status, format_task_label, maybe_strip_writer,
+    write_leaf_trailing_output,
 };
 use crate::session::event::{CacheStatus, CacheUpdateStatus, ExecutionError};
 
@@ -20,11 +21,21 @@ use writer::GroupedWriter;
 pub struct GroupedReporterBuilder {
     workspace_path: Arc<AbsolutePath>,
     writer: Box<dyn Write>,
+    color_support: ColorSupport,
 }
 
 impl GroupedReporterBuilder {
-    pub fn new(workspace_path: Arc<AbsolutePath>, writer: Box<dyn Write>) -> Self {
-        Self { workspace_path, writer }
+    /// Grouped mode buffers child output and flushes it through `writer`
+    /// at finish time. The pipe writers themselves (see
+    /// `LeafExecutionReporter::start`) strip ANSI on the way into the buffer,
+    /// so by the time the buffer reaches `writer` it already matches the
+    /// terminal's colour capability. `writer` is therefore stored unwrapped.
+    pub fn new(
+        workspace_path: Arc<AbsolutePath>,
+        writer: Box<dyn Write>,
+        color_support: ColorSupport,
+    ) -> Self {
+        Self { workspace_path, writer, color_support }
     }
 }
 
@@ -33,13 +44,15 @@ impl GraphExecutionReporterBuilder for GroupedReporterBuilder {
         Box::new(GroupedGraphReporter {
             writer: Rc::new(RefCell::new(self.writer)),
             workspace_path: self.workspace_path,
+            color_support: self.color_support,
         })
     }
 }
 
 struct GroupedGraphReporter {
     writer: Rc<RefCell<Box<dyn Write>>>,
     workspace_path: Arc<AbsolutePath>,
+    color_support: ColorSupport,
 }
 
 impl GraphExecutionReporter for GroupedGraphReporter {
@@ -56,6 +69,7 @@ impl GraphExecutionReporter for GroupedGraphReporter {
             label,
             started: false,
             grouped_buffer: None,
+            color_support: self.color_support,
         })
     }
 
@@ -73,6 +87,7 @@ struct GroupedLeafReporter {
     label: vite_str::Str,
     started: bool,
     grouped_buffer: Option<Rc<RefCell<Vec<u8>>>>,
+    color_support: ColorSupport,
 }
 
 impl LeafExecutionReporter for GroupedLeafReporter {
@@ -95,8 +110,14 @@ impl LeafExecutionReporter for GroupedLeafReporter {
         StdioConfig {
             suggestion: StdioSuggestion::Piped,
             writers: PipeWriters {
-                stdout_writer: Box::new(GroupedWriter::new(Rc::clone(&buffer))),
-                stderr_writer: Box::new(GroupedWriter::new(buffer)),
+                stdout_writer: maybe_strip_writer(
+                    Box::new(GroupedWriter::new(Rc::clone(&buffer))),
+                    self.color_support.stdout,
+                ),
+                stderr_writer: maybe_strip_writer(
+                    Box::new(GroupedWriter::new(buffer)),
+                    self.color_support.stderr,
+                ),
             },
         }
     }
@@ -152,7 +173,11 @@ mod tests {
         let task = spawn_task("build");
         let item = &task.items[0];
 
-        let builder = Box::new(GroupedReporterBuilder::new(test_path(), Box::new(std::io::sink())));
+        let builder = Box::new(GroupedReporterBuilder::new(
+            test_path(),
+            Box::new(std::io::sink()),
+            ColorSupport::uniform(false),
+        ));
         let mut reporter = builder.build();
         let mut leaf = reporter.new_leaf_execution(&item.execution_item_display, leaf_kind(item));
         let stdio_config = leaf.start(CacheStatus::Disabled(CacheDisabledReason::NoCacheMetadata));