Colored Terminal Output

18 min readupdated by

Ahmet Zeybek· Jul 10, 2026

How to add color and styling to a command-line tool’s output in Rust, the way you would with chalk or picocolors in Node.js, and, importantly, how to make that color disappear cleanly when output is piped to a file or when the user sets NO_COLOR.

Quick Overview

Color in a terminal is just ANSI escape codes: short byte sequences like \x1b[32m (green on) and \x1b[39m (default foreground) wrapped around your text. In Node.js you reach for chalk, picocolors, or kleur; in Rust the go-to crates are owo-colors (zero-cost styling extension methods), anstream (a smart stdout/stderr that strips color when it shouldn’t be there), anstyle (the style vocabulary clap and Cargo speak), and console (batteries-included, auto-detecting). The single most important thing this page teaches: respect NO_COLOR and don’t emit escape codes into pipes. Getting this right is the difference between a polished tool and one that dumps \x1b[32m garbage into log files.

The repository’s pinned verification toolchain uses the 2024 edition; cargo new selects that edition automatically.

TypeScript/JavaScript Example

In Node.js, chalk is the household name, though the tiny picocolors has largely won on size and speed. Both auto-detect whether output is a terminal and honor the NO_COLOR / FORCE_COLOR conventions for you.

1
// npm install chalk    (chalk v5 is ESM-only)
2
import chalk from "chalk";
3

4
// Basic colors and styles
5
console.log(chalk.green("Success!"));
6
console.log(chalk.yellow("Warning!"));
7
console.log(chalk.red.bold("Error!"));
8
console.log(`${chalk.blue("INFO")} Server started`);
9

10
// Background colors, combinations, truecolor
11
console.log(chalk.white.bgRed.bold("Alert"));
12
console.log(chalk.dim("dimmed note"));
13
console.log(chalk.underline("underlined"));
14
console.log(chalk.rgb(255, 128, 0)("custom rgb"));
15

16
// A cargo-style diagnostic
17
function report(level: "info" | "warning" | "error", message: string) {
18
  const tag = {
19
    info: chalk.green.bold("info"),
20
    warning: chalk.yellow.bold("warning"),
21
    error: chalk.red.bold("error"),
22
  }[level];
23
  const line = `${tag}: ${message}`;
24
  if (level === "error") console.error(line);
25
  else console.log(line);
26
}
27

28
report("info", "compiling 12 modules");
29
report("error", "could not build");

Chalk decides at runtime whether to emit codes. If you run node app.js | cat, or set NO_COLOR=1, chalk produces plain text automatically. That auto-detection is the behavior we want to reproduce in Rust, and as you’ll see, not every Rust crate does it for you by default.

Rust Equivalent

The idiomatic modern stack is owo-colors for the styling syntax plus anstream for a terminal-aware output stream. owo-colors gives you chalk-like extension methods; anstream’s println! is a drop-in that strips the codes when the destination is not a real terminal or when NO_COLOR is set.

Add the dependencies (in a fresh cargo new project):

1
cargo add owo-colors
2
cargo add anstream

1
use anstream::println; // terminal-aware: strips ANSI when not a TTY / NO_COLOR set
2
use owo_colors::OwoColorize;
3

4
fn main() {
5
    // Basic colors and styles — same vocabulary as chalk
6
    println!("{}", "Success!".green());
7
    println!("{}", "Warning!".yellow());
8
    println!("{}", "Error!".red().bold());
9
    println!("{} {}", "INFO".blue(), "Server started");
10

11
    // Background colors, combinations, truecolor
12
    println!("{}", "Alert".white().on_red().bold());
13
    println!("{}", "dimmed note".dimmed());
14
    println!("{}", "underlined".underline());
15
    println!("{}", "custom rgb".truecolor(255, 128, 0));
16
}

Tip: The split is deliberate. owo-colors only describes the style; anstream decides whether to keep it. You can swap either piece independently — e.g. use owo-colors with a plain std::println! and your own detection, or use anstream with anstyle instead of owo-colors.

Here is the same report helper, written so color is automatically disabled in pipes and under NO_COLOR:

1
use anstream::{eprintln, println};
2
use owo_colors::OwoColorize;
3
use std::fmt::Display;
4

5
enum Level {
6
    Info,
7
    Warn,
8
    Error,
9
}
10

11
impl Level {
12
    fn label(&self) -> String {
13
        match self {
14
            Level::Info => "info".green().bold().to_string(),
15
            Level::Warn => "warning".yellow().bold().to_string(),
16
            Level::Error => "error".red().bold().to_string(),
17
        }
18
    }
19
}
20

21
fn report(level: Level, message: impl Display) {
22
    let line = format!("{}: {}", level.label(), message);
23
    match level {
24
        Level::Error => eprintln!("{line}"),
25
        _ => println!("{line}"),
26
    }
27
}
28

29
fn main() {
30
    report(Level::Info, "compiling 12 crates");
31
    report(Level::Warn, "unused import: `std::env`");
32
    report(Level::Error, "could not compile `app` (bin \"app\")");
33
}

Run through a pipe, the ANSI codes are gone:

1
cargo run -q | cat

1
info: compiling 12 crates
2
warning: unused import: `std::env`

(The error line goes to stderr, so it doesn’t show in the piped stdout, exactly like Cargo.)

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

use owo_colors::OwoColorize; brings a trait into scope that adds methods like .green(), .bold(), and .on_red() to every type that implements Display (and Debug). This is the same ergonomic trick TypeScript devs know from prototype extension, but checked at compile time.

The key subtlety: .green() does not return a String. It returns a tiny wrapper struct — FgColorDisplay<'_, Red, &str> (here Red is shorthand for owo_colors::colors::Red, the fully-qualified path the compiler prints in the Pitfall 1 error below) — that holds a reference to your value and remembers the style. No allocation, no escape codes are produced until the value is actually formatted. When you eventually println!("{}", x.green()), the wrapper’s Display implementation writes the green escape code (\x1b[32m) before your value and a reset (\x1b[39m) after — the escape codes exist only for the duration of that one format call.

console: chalk-style convenience with auto-detection

console — the same crate family behind Progress Bars and Spinners with indicatif — takes the chalk approach: console::style(..) returns a StyledObject that auto-detects by default, so you don’t need a separate stream.

1
cargo add console

1
use console::style;
2

3
fn main() {
4
    // Auto-detects TTY + NO_COLOR/CLICOLOR; only emits ANSI when appropriate.
5
    println!("{}", style("Deploy succeeded").green().bold());
6
    println!("{}", style("Retrying...").yellow());
7

8
    // Override the decision explicitly when you must:
9
    println!("{}", style("always red").red().force_styling(true));
10
}

Piped, the auto-detecting styles vanish but the forced one survives (raw bytes):

1
"Deploy succeeded\nRetrying...\n\x1b[31malways red\x1b[0m\n"

anstyle: the shared styling vocabulary

You will rarely reach for anstyle directly — it is the minimal, dependency-free crate the rest of the ecosystem agreed on to describe a style (it is the same vocabulary clap renders its colored --help with — see Parsing Arguments with the clap Derive API), but it’s worth recognizing:

1
use anstyle::{AnsiColor, Color, Style};
2

3
fn main() {
4
    let heading = Style::new()
5
        .bold()
6
        .fg_color(Some(Color::Ansi(AnsiColor::Green)));
7

8
    // `{heading}` writes the opening sequence; `{heading:#}` writes the reset.
9
    println!("{heading}Section{heading:#}");
10
    // Equivalent, spelled out:
11
    println!("{}Section{}", heading.render(), heading.render_reset());
12
}

Both lines produce the same bytes — \x1b[1m\x1b[32mSection\x1b[0m. anstyle is just the codes; it has no opinion about detection, which is precisely why higher-level crates build on it.

Key Differences

Concern	TypeScript (chalk / picocolors)	Rust
How styling attaches	Functions wrapping strings	Trait methods (`OwoColorize`) on any `Display` type, or `style(..)` wrappers
Return value of `.green()`	A new `string`	A lazy zero-cost wrapper (owo-colors) or `StyledObject` (console) — not a `String`
Auto terminal detection	Built in, on by default	owo-colors: off by default; console: on; anstream: on at the stream
`NO_COLOR` honored	Yes, automatically	Yes, via anstream, console, or owo-colors’ `supports-colors` feature; not by raw owo-colors
Force color	`FORCE_COLOR=1`	`CLICOLOR_FORCE=1` (anstream/console), or explicit `force_styling(true)` / `set_override(true)`
Output target awareness	One `console.log`	Choose: terminal-aware `anstream::println!` vs raw `std::println!`

The headline conceptual difference: chalk couples styling and detection; the Rust ecosystem deliberately decouples them. owo-colors answers “what does green look like?” while anstream answers “should this stream show green right now?”. This separation is more verbose for a hello-world, but it scales: you set the policy once at the output boundary and never branch on NO_COLOR in business logic. If you want the chalk-style all-in-one feel, reach for console.

Note: NO_COLOR (see https://no-color.org) is a cross-language convention: if the variable is present and non-empty, applications should not emit color. CLICOLOR_FORCE (non-empty) forces color on even when piped. These are the same conventions Cargo, ripgrep, and most modern CLIs follow.

Common Pitfalls

Pitfall 1: Treating a styled value like a `String`

A TypeScript dev expects "error".red() to be a string and tries to +-concatenate it like JavaScript:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let msg = "error".red() + ": something broke"; // does not compile (error[E0369])
5
    println!("{}", msg);
6
}

The real compiler error:

1
error[E0369]: cannot add `&str` to `FgColorDisplay<'_, owo_colors::colors::Red, &str>`
2
 --> src/main.rs:6:29
3
  |
4
6 |     let msg = "error".red() + ": something broke";
5
  |               ------------- ^ ------------------- &str
6
  |               |
7
  |               FgColorDisplay<'_, owo_colors::colors::Red, &str>
8
  |
9
note: the foreign item type `FgColorDisplay<'_, owo_colors::colors::Red, &str>`
10
      doesn't implement `Add<&str>`

.red() returns a lazy display wrapper, not a String. The fix is to format the pieces together rather than add them:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let msg = format!("{}: something broke", "error".red());
5
    println!("{msg}");
6
}

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Because raw owo-colors never detects the terminal, this writes escape bytes into a redirected file:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    // std::println! does NO detection; owo-colors does NO detection.
5
    println!("{}", "result".green()); // leaks \x1b[32m...\x1b[39m into pipes/files
6
}

Run cargo run | cat and you’ll see literal \x1b[32m in the output: the exact garbage-in-logs problem. Fix: import anstream::println (or use console::style, or gate with if_supports_color). One-line change:

1
use anstream::println; // ← decides keep-or-strip per stream
2
use owo_colors::OwoColorize;
3

4
fn main() {
5
    println!("{}", "result".green()); // stripped when piped, kept on a TTY
6
}

Pitfall 3: Padding a value that already contains ANSI bytes

Alignment specifiers count bytes, and ANSI escape sequences are bytes. owo-colors’ lazy wrapper is smart — it forwards the format spec to the inner text, so {:<10} pads correctly. But the moment you render a styled value into a String (with .to_string() or format!) and then try to pad it, the width counts the invisible escape bytes:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    // Pre-rendered into a String — width now counts the escape bytes:
5
    let pre_rendered = "OK".green().to_string();
6
    println!("[{:<10}]", pre_rendered); // NOT padded to 10 visible columns
7
}

Raw bytes: [\x1b[32mOK\x1b[39m] — no padding at all, because the formatter saw a 10-byte-ish string of mostly escape characters. Fix: pad the plain text first, then style the padded result:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let padded = format!("{:<10}", "OK");
5
    println!("[{}]", padded.green()); // visible "OK" + 8 spaces, then colored
6
}

Pitfall 4: Forgetting to enable the `supports-colors` feature

If you write use owo_colors::{OwoColorize, Stream}; and call if_supports_color without the feature, you actually get two errors. First, the unresolved import of Stream (E0432) — and this is the one that carries the “configured out / gated behind supports-colors” note. Second, a separate “method not found” (E0599) for if_supports_color, with no note attached:

1
error[E0432]: unresolved import `owo_colors::Stream`
2
 --> src/main.rs:1:31
3
  |
4
1 | use owo_colors::{OwoColorize, Stream};
5
  |                               ^^^^^^ no `Stream` in the root
6
  |
7
note: found an item that was configured out
8
  |
9
  |       --------------------------- the item is gated behind the `supports-colors` feature
10
...
11
  |     supports_colors::{Stream, SupportsColorsDisplay},
12
  |                       ^^^^^^
13

14
error[E0599]: no method named `if_supports_color` found for reference `&'static str` in the current scope
15
 --> src/main.rs:6:23
16
  |
17
6 |         "conditional".if_supports_color(Stream::Stdout, |t| t.green())
18
  |                       ^^^^^^^^^^^^^^^^^ method not found in `&'static str`

The lesson: the telltale “gated behind the supports-colors feature” note hangs off the Stream import error, not the method error. Fix: cargo add owo-colors --features supports-colors. (Or just use anstream/console, which need no extra feature flags.)

Best Practices

Decide color once, at the output boundary. Route all user-facing output through anstream::stdout()/stderr() (or their macros). Keep your styling code unconditional and free of if NO_COLOR checks.
Respect NO_COLOR and CLICOLOR_FORCE. Don’t roll your own env parsing if you can avoid it; anstream, console, and owo-colors’ supports-colors feature all implement the conventions correctly. The check is: NO_COLOR present and non-empty disables; CLICOLOR_FORCE present and non-empty forces on.
Send errors and diagnostics to stderr, normal output to stdout, and detect each independently. anstream’s stdout() and stderr() evaluate their own stream, so a tool whose stdout is piped but whose stderr is a terminal still colorizes errors.
Prefer named ANSI colors over truecolor for portability. .green() works on virtually every terminal; .truecolor(...) only renders correctly on 24-bit-capable terminals and silently degrades elsewhere.

Give users an explicit --color <auto|always|never> flag, mapping to anstream/owo-colors overrides. This is what Cargo and ripgrep do, and power users expect it. With owo-colors, owo_colors::set_override(true|false) sets a process-wide decision that if_supports_color honors:

1
use owo_colors::{OwoColorize, Stream};
2

3
fn main() {
4
    owo_colors::set_override(false); // e.g. from `--color never`
5
    println!(
6
        "{}",
7
        "forced off".if_supports_color(Stream::Stdout, |t| t.red())
8
    ); // prints plain, even on a TTY
9
}

Don’t hand-write escape codes like "\x1b[32m". They’re error-prone (easy to forget the reset), don’t get stripped automatically, and break on non-ANSI consoles. Let a crate own the bytes.

Warning: A subtle correctness issue: a manual or pre-rendered ANSI string that you later pass through a width/truncation formatter ({:.10}, {:<10}) will miscount, because escape bytes are counted but not displayed. Style after you’ve finished sizing the plain text. See Pitfall 3.

Real-World Example

A small cargo-style diagnostic reporter — the kind of output a linter or build tool emits — that colorizes on a terminal, goes plain in pipes and under NO_COLOR, and sends errors to stderr. This is compile-verified end to end.

Note: This example uses the unconditional-styling pattern (owo-colors always emits codes; anstream strips them at the boundary). With this pattern the user-facing color knobs are the environment variables anstream reads — NO_COLOR and CLICOLOR_FORCE — not owo_colors::set_override. set_override only governs if_supports_color and Style-based rendering (see Exercise 2), neither of which this code uses, so adding a set_override branch here would be a dead no-op. A real --color <auto|always|never> flag must instead be wired into anstream’s ColorChoice (e.g. via anstream::AutoStream constructed with an explicit choice). Exercise 2 shows the override path that does respond to set_override.

Cargo.toml:

1
[dependencies]
2
anstream = "1.0.0"
3
owo-colors = "4.3.0"

src/main.rs:

1
use anstream::{eprintln, println};
2
use owo_colors::OwoColorize;
3
use std::fmt::Display;
4

5
/// A diagnostic severity, like a compiler or linter would emit.
6
enum Level {
7
    Info,
8
    Warn,
9
    Error,
10
}
11

12
impl Level {
13
    /// The styled label. We always apply the style here; `anstream` strips it
14
    /// later if the destination is not a color-capable terminal.
15
    fn label(&self) -> String {
16
        match self {
17
            Level::Info => "info".green().bold().to_string(),
18
            Level::Warn => "warning".yellow().bold().to_string(),
19
            Level::Error => "error".red().bold().to_string(),
20
        }
21
    }
22
}
23

24
/// Print a `level: message` line, routing errors to stderr.
25
fn report(level: Level, message: impl Display) {
26
    let line = format!("{}: {}", level.label(), message);
27
    match level {
28
        Level::Error => eprintln!("{line}"),
29
        _ => println!("{line}"),
30
    }
31
}
32

33
fn main() {
34
    // No per-call color branching: styling is unconditional and `anstream`
35
    // strips it when stdout/stderr isn't a color-capable terminal. The user
36
    // controls color through the environment `anstream` reads — `NO_COLOR`
37
    // disables it, `CLICOLOR_FORCE` forces it on.
38
    report(Level::Info, "compiling 12 crates");
39
    report(
40
        Level::Warn,
41
        format!("unused variable: `{}`", "count".cyan()),
42
    );
43
    report(Level::Error, "could not compile `app` (bin \"app\")");
44
}

Behavior, verified by inspecting raw bytes:

Piped (cargo run -q | cat): every line is plain text; the error line is on stderr.
```
1
info: compiling 12 crates
2
warning: unused variable: `count`
```

On a real terminal (NO_COLOR unset): labels are colored, count is cyan. Raw stdout bytes:

1
"\x1b[1m\x1b[32minfo\x1b[39m\x1b[0m: compiling 12 crates\n"
2
"\x1b[1m\x1b[33mwarning\x1b[39m\x1b[0m: unused variable: `\x1b[36mcount\x1b[39m`\n"

NO_COLOR=1 on a terminal: anstream strips everything; output is identical to the piped case.

This is the whole discipline in one screen: style freely, decide once, route errors correctly, and the conventions take care of themselves.

Exercises

Exercise 1: A leak-proof status line

Difficulty: Easy

Objective: Print a green [ OK ] prefix followed by a message, such that the color disappears when output is piped.

Instructions:

Create a project and cargo add owo-colors anstream.
Write status("Database connected") that prints [ OK ] Database connected with [ OK ] in bold green.
Verify that cargo run -q | cat shows no escape codes, but a real terminal shows green.

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn status(message: &str) {
5
    // TODO: print a bold-green "[ OK ]" prefix, then the message
6
}
7

8
fn main() {
9
    status("Database connected");
10
}

Solution

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn status(message: &str) {
5
    // Style freely; anstream's println! strips codes when not a TTY / NO_COLOR set.
6
    println!("{} {message}", "[ OK ]".green().bold());
7
}
8

9
fn main() {
10
    status("Database connected");
11
}

Piped, this prints exactly [ OK ] Database connected with no escape bytes; on a terminal the prefix is bold green.

Exercise 2: Honor `--color=<auto|always|never>`

Difficulty: Medium

Objective: Add a color policy flag that overrides auto-detection, mirroring Cargo and ripgrep.

Instructions:

Read the first CLI argument. Map --color=always, --color=never, and anything else (auto) to a decision.
Use owo_colors::set_override(..) for always/never; leave it untouched for auto. Enable the supports-colors feature.
Print a line styled via if_supports_color and confirm: --color=always colors even when piped; --color=never is plain even on a TTY; with no flag, it follows the terminal and NO_COLOR.

1
use owo_colors::{OwoColorize, Stream};
2

3
fn main() {
4
    // TODO: parse args[1], set the override, then print a conditional-styled line
5
}

Solution

1
// Cargo.toml:
2
// owo-colors = { version = "4.3.0", features = ["supports-colors"] }
3
use owo_colors::{OwoColorize, Stream, Style};
4

5
fn main() {
6
    match std::env::args().nth(1).as_deref() {
7
        Some("--color=always") => owo_colors::set_override(true),
8
        Some("--color=never") => owo_colors::set_override(false),
9
        _ => {} // auto: if_supports_color does TTY + NO_COLOR detection
10
    }
11

12
    // Build the combined style up front so the closure can apply it in one call.
13
    // (Chaining two methods inside the closure, like `|t| t.green().bold()`,
14
    // fails to compile — the second method would borrow a temporary.)
15
    let style = Style::new().green().bold();
16
    println!(
17
        "{}",
18
        "build finished".if_supports_color(Stream::Stdout, |t| t.style(style))
19
    );
20
}

set_override(true) forces the closure to run (color on) regardless of TTY/NO_COLOR; set_override(false) forces it off; with neither, if_supports_color consults the stream and the NO_COLOR/CLICOLOR environment.

Exercise 3: A padded, colorized two-column report

Difficulty: Hard

Objective: Print an aligned two-column table (label left, value right) with colored labels — without the alignment breaking on the escape bytes.

Instructions:

Given pairs like ("Status", "online") and ("Latency", "12ms"), print each as label left-padded to 12 columns, then the value.
Color labels cyan and the "online" value green. The columns must line up visually.
The catch: you must pad the plain label to width before styling it (recall Pitfall 3). Verify alignment by piping to cat (codes stripped) — columns should still line up.

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn row(label: &str, value: &str) {
5
    // TODO: left-pad `label` to 12 columns of PLAIN text, then color it,
6
    // then print the value (green if "online", else default)
7
}
8

9
fn main() {
10
    row("Status", "online");
11
    row("Latency", "12ms");
12
    row("Region", "us-east-1");
13
}

Solution

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn row(label: &str, value: &str) {
5
    // 1) Size the PLAIN text first so the width counts visible columns only.
6
    let padded = format!("{label:<12}");
7
    // 2) Style the already-padded label.
8
    let styled_label = padded.cyan();
9
    // 3) Conditionally color the value.
10
    if value == "online" {
11
        println!("{styled_label}{}", value.green().bold());
12
    } else {
13
        println!("{styled_label}{value}");
14
    }
15
}
16

17
fn main() {
18
    row("Status", "online");
19
    row("Latency", "12ms");
20
    row("Region", "us-east-1");
21
}

Piped output (codes stripped by anstream) lines up correctly:

1
Status      online
2
Latency     12ms
3
Region      us-east-1

On a terminal the labels are cyan and online is bold green, with the same alignment. Had we written format!("{:<12}", "Status".cyan()), the lazy owo-colors wrapper would actually still align (it forwards the spec) — but the moment you pre-render with .to_string(), alignment breaks. Padding the plain text first is the reliable habit.

Colored Terminal Output

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

console: chalk-style convenience with auto-detection

anstyle: the shared styling vocabulary

Key Differences

Common Pitfalls

Pitfall 1: Treating a styled value like a `String`

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Pitfall 3: Padding a value that already contains ANSI bytes

Pitfall 4: Forgetting to enable the `supports-colors` feature

Best Practices

Real-World Example

Further Reading

Official Documentation

Exercises

Exercise 1: A leak-proof status line

Exercise 2: Honor `--color=<auto|always|never>`

Exercise 3: A padded, colorized two-column report

Colored Terminal Output

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

console: chalk-style convenience with auto-detection

anstyle: the shared styling vocabulary

Key Differences

Common Pitfalls

Pitfall 1: Treating a styled value like a String

Pitfall 2: Using std::println! with owo-colors and leaking codes

Pitfall 3: Padding a value that already contains ANSI bytes

Pitfall 4: Forgetting to enable the supports-colors feature

Best Practices

Real-World Example

Further Reading

Official Documentation

Related Sections in This Guide

Exercises

Exercise 1: A leak-proof status line

Exercise 2: Honor --color=<auto|always|never>

Exercise 3: A padded, colorized two-column report

Pitfall 1: Treating a styled value like a `String`

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Pitfall 4: Forgetting to enable the `supports-colors` feature

Exercise 2: Honor `--color=<auto|always|never>`