fix(ext/node): stop coloring non-TTY streams in util.styleText (#35236)

Fixes #35203.

<img width="522" height="152" alt="grafik"
src="https://github.com/user-attachments/assets/cc2b9611-16b0-46f7-bffb-9c60123c7083"
/>

None of this was done using any LLMs but I briefly looked at the diff of
#35204 to see the relevant files so if the scope of the fix is broader
and the LLM missed it then I may have made the same mistake.

<!--
IMPORTANT: If you used AI tools (e.g. Copilot, ChatGPT, Claude, Cursor,
etc.)
to help write this PR, you MUST disclose it in the PR description. PRs
will be
rejected if there is suspicion of undisclosed AI usage.

Before submitting a PR, please read
https://docs.deno.com/runtime/manual/references/contributing

1. Give the PR a descriptive title.

  Examples of good title:
    - fix(ext/net): fix race condition in TCP listener
    - docs(runtime): update permissions API docstrings
    - feat(cli): add --env-file flag to `deno run`
    - refactor(ext/node): simplify Buffer.from() implementation
    - test(ext/fs): add spec tests for symlink resolution

  Examples of bad title:
    - fix #7123
    - update docs
    - fix bugs

2. Ensure there is a related issue and it is referenced in the PR text.
3. Ensure there are tests that cover the changes.
4. Ensure `./x fmt` passes without changing files.
5. Ensure `./x lint` passes.
6. If you used AI tools to help write this PR, you MUST disclose it
below.
   PRs will be rejected if there is suspicion of undisclosed AI usage.
7. Open as a draft PR if your work is still in progress. The CI won't
run
   all steps, but you can add '[ci]' to a commit message to force it to.
8. If you would like to run the benchmarks on the CI, add the 'ci-bench'
label.
-->

Author: KnorpelSenf

ext/node/lib.rs

@@ -614,6 +614,7 @@ deno_core::extension!(deno_node,
     "internal_binding/constants.ts",
     "internal_binding/_libuv_winerror.ts",
     "internal_binding/uv.ts",
+    "internal/util/colorize.mjs",
     "internal/util/inspect.mjs",
     "internal/errors.ts",
     "internal/errors/error_source.ts",

ext/node/polyfills/internal/util.mjs

@@ -18,6 +18,9 @@ const { os } = core.loadExtScript(
 const { validateFunction } = core.loadExtScript(
   "ext:deno_node/internal/validators.mjs",
 );
+const { shouldColorize } = core.loadExtScript(
+  "ext:deno_node/internal/util/colorize.mjs",
+);
 const { isNativeError } = core.loadExtScript(
   "ext:deno_node/internal/util/types.ts",
 );
@@ -295,6 +298,7 @@ return {
   pendingDeprecate,
   promisify,
   removeColors,
+  shouldColorize,
   sleep,
   WeakReference,
   default: {
@@ -311,6 +315,7 @@ return {
     pendingDeprecate,
     promisify,
     removeColors,
+    shouldColorize,
     sleep,
   },
 };

ext/node/polyfills/internal/util/colorize.mjs

@@ -0,0 +1,38 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+(function () {
+const { primordials } = __bootstrap;
+const { String } = primordials;
+
+// Mirrors Node's internal/util/colors.shouldColorize so node_compat tests
+// that flip FORCE_COLOR / NODE_DISABLE_COLORS / NO_COLOR / TERM=dumb behave
+// like Node. NO_COLOR / NODE_DISABLE_COLORS / TERM=dumb only apply via
+// `stream.getColorDepth()` (matching Node's tty.WriteStream.getColorDepth)
+// or under FORCE_COLOR; a non-TTY plain stream stays at `false`, while a
+// fake stream with `isTTY=true` and no `getColorDepth` returns `true`.
+function shouldColorize(stream) {
+  const env = globalThis.process.env || {};
+  if (env.FORCE_COLOR !== undefined) {
+    const v = String(env.FORCE_COLOR);
+    if (v === "0" || v === "false") return false;
+    if (
+      (env.NODE_DISABLE_COLORS !== undefined &&
+        env.NODE_DISABLE_COLORS !== "") ||
+      (env.NO_COLOR !== undefined && env.NO_COLOR !== "") ||
+      env.TERM === "dumb"
+    ) {
+      // FORCE_COLOR with any non-default value still wins in Node 20+.
+      return v !== "" && v !== "0";
+    }
+    return true;
+  }
+  if (!stream?.isTTY) return false;
+  if (typeof stream.getColorDepth === "function") {
+    return stream.getColorDepth() > 2;
+  }
+  // Match Node: TTY-flagged stream with no getColorDepth defaults to colorful.
+  return true;
+}
+
+return { shouldColorize };
+})();

ext/node/polyfills/internal/util/inspect.mjs

@@ -61,6 +61,9 @@ const {
   validateString,
 } = core.loadExtScript("ext:deno_node/internal/validators.mjs");
 const { codes } = core.loadExtScript("ext:deno_node/internal/error_codes.ts");
+const { shouldColorize } = core.loadExtScript(
+  "ext:deno_node/internal/util/colorize.mjs",
+);
 const {
   colors,
   createStylizeWithColor,
@@ -658,27 +661,49 @@ function styleText(format, text, options) {
   const validateStream = options?.validateStream ?? true;
   validateBoolean(validateStream, "options.validateStream");
 
+  // Match node: validate stream before any format validation, so any
+  // ERR_INVALID_ARG_TYPE always gets throws regardless of
+  // `ERR_INVALID_ARG_VALUE` errors.
   if (validateStream) {
     const stream = options?.stream;
-    if (
-      stream !== undefined && stream !== null &&
-      // Match Node's lib/util.js: bail when `stream` is not a Readable/
-      // Writable/Node Stream. Approximate the duck-type used in those checks.
-      !(typeof stream === "object" && (
-        typeof stream.read === "function" ||
-        typeof stream.write === "function" ||
-        typeof stream.pipe === "function"
-      ))
-    ) {
-      throw new codes.ERR_INVALID_ARG_TYPE(
-        "stream",
-        ["ReadableStream", "WritableStream", "Stream"],
-        stream,
-      );
+    if (stream !== undefined && stream !== null) {
+      // Match Node: bail when `stream` is not a Readable/Writable/Node Stream.
+      // Approximate the duck-type used in those checks.
+      if (
+        !(typeof stream === "object" && (
+          typeof stream.read === "function" ||
+          typeof stream.write === "function" ||
+          typeof stream.pipe === "function"
+        ))
+      ) {
+        throw new codes.ERR_INVALID_ARG_TYPE(
+          "stream",
+          ["ReadableStream", "WritableStream", "Stream"],
+          stream,
+        );
+      }
     }
   }
 
+  // Match Node: validate format even when colorizing is skipped, so
+  // ERR_INVALID_ARG_VALUE is always thrown regardless of TTY state.
   const formatArray = ArrayIsArray(format) ? format : [format];
+  for (let i = 0; i < formatArray.length; i++) {
+    const key = formatArray[i];
+    if (key === "none") continue;
+    if (inspect.colors[key] == null) {
+      validateOneOf(key, "format", ObjectKeys(inspect.colors));
+    }
+  }
+
+  if (validateStream) {
+    // Match Node defaulting stream to process.stdout: when no stream is
+    // provided the colorize check still runs against stdout.
+    const effectiveStream = options?.stream ?? globalThis.process?.stdout;
+    if (!shouldColorize(effectiveStream)) {
+      return text;
+    }
+  }
 
   let openCodes = "";
   let closeCodes = "";
@@ -689,9 +714,6 @@ function styleText(format, text, options) {
     if (key === "none") continue;
 
     const formatCodes = inspect.colors[key];
-    if (formatCodes == null) {
-      validateOneOf(key, "format", ObjectKeys(inspect.colors));
-    }
     const openNum = formatCodes[0];
     const closeNum = formatCodes[1];
     const openSeq = kStyleTextEscape + openNum + kStyleTextEscapeEnd;

ext/node/polyfills/repl.ts

@@ -74,6 +74,9 @@ const {
 const { validateFunction } = core.loadExtScript(
   "ext:deno_node/internal/validators.mjs",
 );
+const { shouldColorize } = core.loadExtScript(
+  "ext:deno_node/internal/util.mjs",
+);
 const vm = core.loadExtScript("ext:deno_node/vm.js").default;
 import process from "node:process";
 import path from "node:path";
@@ -194,36 +197,6 @@ function _removeNewListenerGuard() {
   }
 }
 
-// Mirrors Node's internal/util/colors.shouldColorize so node_compat tests
-// that flip FORCE_COLOR / NODE_DISABLE_COLORS / NO_COLOR / TERM=dumb behave
-// like Node. NO_COLOR / NODE_DISABLE_COLORS / TERM=dumb only apply via
-// `stream.getColorDepth()` (matching Node's tty.WriteStream.getColorDepth)
-// or under FORCE_COLOR; a non-TTY plain stream stays at `false`, while a
-// fake stream with `isTTY=true` and no `getColorDepth` returns `true`.
-function _shouldColorize(stream: any): boolean {
-  const env = (process as any).env || {};
-  if (env.FORCE_COLOR !== undefined) {
-    const v = String(env.FORCE_COLOR);
-    if (v === "0" || v === "false") return false;
-    if (
-      (env.NODE_DISABLE_COLORS !== undefined &&
-        env.NODE_DISABLE_COLORS !== "") ||
-      (env.NO_COLOR !== undefined && env.NO_COLOR !== "") ||
-      env.TERM === "dumb"
-    ) {
-      // FORCE_COLOR with any non-default value still wins in Node 20+.
-      return v !== "" && v !== "0";
-    }
-    return true;
-  }
-  if (!stream?.isTTY) return false;
-  if (typeof stream.getColorDepth === "function") {
-    return stream.getColorDepth() > 2;
-  }
-  // Match Node: TTY-flagged stream with no getColorDepth defaults to colorful.
-  return true;
-}
-
 const reAtFrame = new SafeRegExp(/^\s+at\s/);
 const reExtFrame = new SafeRegExp(/\bext:[a-z_]+\//);
 const reNodeParenFrame = new SafeRegExp(/\(node:[a-z_]+:/);
@@ -668,7 +641,7 @@ export class REPLServer extends (Interface as any) {
     const usePreview = previewSession !== null;
 
     if (options.terminal && options.useColors === undefined) {
-      options.useColors = _shouldColorize(options.output);
+      options.useColors = shouldColorize(options.output);
     }
 
     // Default prompt

tests/unit_node/util_test.ts

@@ -10,6 +10,7 @@ import { stripAnsiCode } from "@std/fmt/colors";
 import * as util from "node:util";
 import utilDefault from "node:util";
 import { Buffer } from "node:buffer";
+import process from "node:process";
 
 Deno.test({
   name: "[util] format",
@@ -262,15 +263,88 @@ Deno.test("[util] aborted() drops pending promise when resource is GCed", async
 });
 
 Deno.test("[util] styleText()", () => {
-  const redText = util.styleText("red", "error");
+  const redText = util.styleText("red", "error", { validateStream: false });
   assertEquals(redText, "\x1B[31merror\x1B[39m");
 });
 
 Deno.test("[util] styleText() with array of formats", () => {
-  const colored = util.styleText(["red", "green"], "error");
+  const colored = util.styleText(["red", "green"], "error", {
+    validateStream: false,
+  });
   assertEquals(colored, "\x1b[31m\x1b[32merror\x1b[39m\x1b[39m");
 });
 
+Deno.test("[util] styleText() respects stream.isTTY", () => {
+  const streamTTY = {
+    write() {},
+    isTTY: true,
+  } as unknown as NodeJS.WritableStream;
+  const streamNoTTY = {
+    write() {},
+    isTTY: false,
+  } as unknown as NodeJS.WritableStream;
+
+  const redText = util.styleText("red", "TTY", { stream: streamTTY });
+  assertEquals(redText, "\x1b[31mTTY\x1b[39m");
+
+  const plainText = util.styleText("blue", "No TTY", { stream: streamNoTTY });
+  const greenText = util.styleText("green", "No TTY", {
+    stream: streamNoTTY,
+    validateStream: false,
+  });
+  assertEquals(plainText, "No TTY");
+  assertEquals(greenText, "\x1b[32mNo TTY\x1b[39m");
+});
+
+Deno.test("[util] styleText() falls back to process.stdout when no stream given", () => {
+  const orig = process.env.FORCE_COLOR;
+  try {
+    process.env.FORCE_COLOR = "0";
+    assertEquals(util.styleText("red", "no stream"), "no stream");
+
+    process.env.FORCE_COLOR = "1";
+    assertEquals(
+      util.styleText("red", "no stream"),
+      "\x1b[31mno stream\x1b[39m",
+    );
+  } finally {
+    if (orig === undefined) {
+      delete process.env.FORCE_COLOR;
+    } else {
+      process.env.FORCE_COLOR = orig;
+    }
+  }
+});
+
+Deno.test("[util] styleText() validates stream type before format", () => {
+  // When both the stream and the format are invalid, ERR_INVALID_ARG_TYPE
+  // (bad stream) must be thrown before ERR_INVALID_ARG_VALUE (bad format),
+  // matching Node's argument-validation order.
+  const streamErr = assertThrows(
+    () =>
+      // @ts-expect-error: intentionally invalid format and stream to test validation order
+      util.styleText("not_a_valid_format", "text", { stream: "not-a-stream" }),
+    TypeError,
+  );
+  assertEquals(
+    (streamErr as unknown as { code: string }).code,
+    "ERR_INVALID_ARG_TYPE",
+  );
+
+  // With a structurally-valid stream (has .write), the format check fires next
+  // and ERR_INVALID_ARG_VALUE is thrown.
+  const formatErr = assertThrows(
+    () =>
+      // @ts-expect-error: intentionally invalid format to test validation order
+      util.styleText("not_a_valid_format", "text", { stream: { write() {} } }),
+    TypeError,
+  );
+  assertEquals(
+    (formatErr as unknown as { code: string }).code,
+    "ERR_INVALID_ARG_VALUE",
+  );
+});
+
 Deno.test("[util] stripVTControlCharacters() removes OSC 8 hyperlinks", () => {
   // OSC 8 hyperlink with ESC \ (ST) terminator
   const input =