Tuve que cambiar el color de fondo de la consola a blanco debido a problemas oculares, pero la fuente es de color gris y hace que los mensajes sean ilegibles. ¿Cómo puedo cambiarlo?

A continuación puede encontrar la referencia de colores del texto al comando cuando ejecuta la aplicación node.js:

console.log('\x1b[36m%s\x1b[0m', 'I am cyan');  //cyan
console.log('\x1b[33m%s\x1b[0m', stringToMakeYellow);  //yellow

La nota %ses dónde se inyecta la cadena (el segundo argumento). \x1b[0mrestablece el color del terminal para que ya no siga siendo el color elegido después de este punto.

Referencia de colores

Reset = "\x1b[0m"
Bright = "\x1b[1m"
Dim = "\x1b[2m"
Underscore = "\x1b[4m"
Blink = "\x1b[5m"
Reverse = "\x1b[7m"
Hidden = "\x1b[8m"

FgBlack = "\x1b[30m"
FgRed = "\x1b[31m"
FgGreen = "\x1b[32m"
FgYellow = "\x1b[33m"
FgBlue = "\x1b[34m"
FgMagenta = "\x1b[35m"
FgCyan = "\x1b[36m"
FgWhite = "\x1b[37m"

BgBlack = "\x1b[40m"
BgRed = "\x1b[41m"
BgGreen = "\x1b[42m"
BgYellow = "\x1b[43m"
BgBlue = "\x1b[44m"
BgMagenta = "\x1b[45m"
BgCyan = "\x1b[46m"
BgWhite = "\x1b[47m"

EDITAR:

Por ejemplo, \x1b[31mes una secuencia de escape que será interceptada por su terminal y le indica que cambie al color rojo. De hecho, \x1bes el código para el carácter de control no imprimible escape . Las secuencias de escape que se ocupan solo de colores y estilos también se conocen como código de escape ANSI y están estandarizadas, por lo que (deberían) funcionar en cualquier plataforma.

Wikipedia tiene una buena comparación de cómo los diferentes terminales muestran colores https://en.wikipedia.org/wiki/ANSI_escape_code#Colors

Hay varios paquetes disponibles para formatear el texto de la consola en Node.js. Los más populares son:

• chalk
• cli-color
• colors
  
  

Uso:

TIZA:

const chalk = require('chalk');
console.log(chalk.red('Text in red'));

CLI-COLOR:

const clc = require('cli-color');
console.log(clc.red('Text in red'));

COLORES:

const colors = require('colors');
console.log('Text in red'.red);

Muchas personas han notado su desaprobación de colorsalterar el prototipo de String . Si prefiere que sus prototipos se queden solos, use el siguiente código:

const colors = require('colors/safe');
console.log(colors.red('Text in red'));

Si desea cambiar los colores directamente sin un módulo, intente

console.log('\x1b[36m', 'sometext' ,'\x1b[0m');

Primero \x1b[36mpara cambiar los colores a 36y luego volver al color terminal 0.

Aquí hay una lista de códigos de color ANSI

para colorear su salida Puede usar ejemplos desde allí:
https://help.ubuntu.com/community/CustomizingBashPrompt

También un Gist para nodeJs

Por ejemplo, si desea parte del texto en color rojo, solo haga console.log con:

"\033[31m this will be red \033[91m and this will be normal"

En base a eso, he creado la extensión "colog" para Node.js. Puedes instalarlo usando:

npm install colog

Repo y npm: https://github.com/dariuszp/colog

Esta es una lista de colores disponibles (fondo, primer plano) en la consola con acciones disponibles (restablecer, invertir, ...).

const colors = {
 Reset: "\x1b[0m",
 Bright: "\x1b[1m",
 Dim: "\x1b[2m",
 Underscore: "\x1b[4m",
 Blink: "\x1b[5m",
 Reverse: "\x1b[7m",
 Hidden: "\x1b[8m",
 fg: {
  Black: "\x1b[30m",
  Red: "\x1b[31m",
  Green: "\x1b[32m",
  Yellow: "\x1b[33m",
  Blue: "\x1b[34m",
  Magenta: "\x1b[35m",
  Cyan: "\x1b[36m",
  White: "\x1b[37m",
  Crimson: "\x1b[38m" //القرمزي
 },
 bg: {
  Black: "\x1b[40m",
  Red: "\x1b[41m",
  Green: "\x1b[42m",
  Yellow: "\x1b[43m",
  Blue: "\x1b[44m",
  Magenta: "\x1b[45m",
  Cyan: "\x1b[46m",
  White: "\x1b[47m",
  Crimson: "\x1b[48m"
 }
};

Úselo de la siguiente manera:

 console.log(colors.bg.Blue, colors.fg.White , "I am white message with blue background", colors.Reset) ; 
 //don't forget "colors.Reset" to stop this color and return back to the default color

También puedes instalar:

npm install console-info console-warn console-error --save-dev

TI le dará una salida más cercana a la consola del lado del cliente:

Según esta documentación , puede cambiar los colores según el tipo de datos de la salida:

// you'll need the util module
var util = require('util');

// let's look at the defaults: 
util.inspect.styles

{ special: 'cyan',
  number: 'yellow',
  boolean: 'yellow',
  undefined: 'grey',
  null: 'bold',
  string: 'green',
  date: 'magenta',
  regexp: 'red' }

// what are the predefined colors?
util.inspect.colors

{ bold: [ 1, 22 ],
  italic: [ 3, 23 ],
  underline: [ 4, 24 ],
  inverse: [ 7, 27 ],
  white: [ 37, 39 ],
  grey: [ 90, 39 ],
  black: [ 30, 39 ],
  blue: [ 34, 39 ],
  cyan: [ 36, 39 ],
  green: [ 32, 39 ],
  magenta: [ 35, 39 ],
  red: [ 31, 39 ],
  yellow: [ 33, 39 ] }

Estos parecen ser códigos de escape ANSI SGR, donde el primer número es el código a emitir antes de la salida, y el segundo número es el código a emitir después. Entonces, si miramos la tabla de códigos ANSI SGR en Wikipedia , verá que la mayoría de estos comienzan con un número 30-37 para establecer el color de primer plano, y terminan en 39 para restablecer el color de primer plano predeterminado.

Entonces, una cosa que no me gusta es cuán oscuros son algunos de estos. Especialmente fechas. Sigue adelante y prueba new Date()en la consola. El magenta oscuro sobre negro es realmente difícil de leer. Cambiemos eso a un magenta claro.

// first define a new color
util.inspect.colors.lightmagenta = [95,39];

// now assign it to the output for date types
util.inspect.styles.date = 'lightmagenta';

Ahora cuando lo intentas new Date(), la salida es mucho más legible.

Si desea establecer colores automáticamente al iniciar el nodo, cree un script que inicie la respuesta, de esta manera:

// set your colors however desired
var util = require('util');
util.inspect.colors.lightmagenta = [95,39];
util.inspect.styles.date = 'lightmagenta';

// start the repl    
require('repl').start({});

Guarde este archivo (por ejemplo, init.js), luego ejecútelo node.exe init.js. Establecerá los colores y ejecutará el símbolo del sistema node.js.

(Gracias a loganfsmyth en esta respuesta por la idea de respuesta ).

Esta biblioteca de Sindre Sorhus es la mejor en este momento:

tiza

• De alto rendimiento
• No se extiende String.prototype
• API expresiva
• Posibilidad de anidar estilos
• Limpio y enfocado
• Detecta automáticamente el soporte de color
• Mantenido activamente
• Usado por más de 5500 módulos

Reset: "\x1b[0m"
Bright: "\x1b[1m"
Dim: "\x1b[2m"
Underscore: "\x1b[4m"
Blink: "\x1b[5m"
Reverse: "\x1b[7m"
Hidden: "\x1b[8m"

FgBlack: "\x1b[30m"
FgRed: "\x1b[31m"
FgGreen: "\x1b[32m"
FgYellow: "\x1b[33m"
FgBlue: "\x1b[34m"
FgMagenta: "\x1b[35m"
FgCyan: "\x1b[36m"
FgWhite: "\x1b[37m"

BgBlack: "\x1b[40m"
BgRed: "\x1b[41m"
BgGreen: "\x1b[42m"
BgYellow: "\x1b[43m"
BgBlue: "\x1b[44m"
BgMagenta: "\x1b[45m"
BgCyan: "\x1b[46m"
BgWhite: "\x1b[47m"

Por ejemplo, si desea tener un texto Dim, rojo con fondo azul, puede hacerlo en Javascript de esta manera:

console.log("\x1b[2m", "\x1b[31m", "\x1b[44m", "Sample Text", "\x1b[0m");

El orden de los colores y los efectos parece no ser tan importante, pero siempre recuerde restablecer los colores y los efectos al final.

Una práctica línea que escribí para scripts npm que no pueden tener dependencias:

const { r, g, b, w, c, m, y, k } = [
  ['r', 1], ['g', 2], ['b', 4], ['w', 7],
  ['c', 6], ['m', 5], ['y', 3], ['k', 0],
].reduce((cols, col) => ({
  ...cols,  [col[0]]: f => `\x1b[3${col[1]}m${f}\x1b[0m`
}), {})

console.log(`${g('I')} love ${r('Italy')}`)

Editar: r,g,b,w,c,m,y,k significa rojo, verde, azul, blanco, cian, magenta, amarillo y blac (k)

Emoji

Puede usar colores para el texto como otros mencionaron en sus respuestas.

¡Pero puedes usar emojis en su lugar! por ejemplo, puede usar Puede usar ⚠️para mensajes de advertencia y 🛑para mensajes de error.

O simplemente use estos cuadernos como color:

📕: error message
📙: warning message
📗: ok status message
📘: action message
📓: canceled status message
📔: Or anything you like and want to recognize immediately by color

Prima:

Este método también lo ayuda a escanear rápidamente y encontrar registros directamente en el código fuente .

_{Pero la fuente de emoji predeterminada de Linux no es colorida por defecto y es posible que primero quieras hacerlas coloridas.}

Para una alternativa popular a los colores que no interfiera con los métodos incorporados del objeto String, recomiendo verificar cli-color .

Incluye tanto colores como estilos encadenables como negrita, cursiva y subrayado.

Para una comparación de varios módulos en esta categoría, vea aquí .

Sin bibliotecas, sin complicaciones, simplemente simple:

console.log(red('Error!'));

function red(s) {
    return '\033[31m' + s;
}

Hay dos formas de ver el cambio de colores para una consola Node.js hoy.

Una es a través de bibliotecas de uso general que pueden decorar una cadena de texto con etiquetas de color, que luego se imprimen a través del estándar console.log.

Las mejores bibliotecas para eso hoy:

• tiza
• colores
• cli-color

Y a la inversa: parchear los métodos de consola existentes. Uno de estos biblioteca - manakin le permite configurar automáticamente los colores estándar para todas sus métodos de consola ( log, warn, errory info).

Una diferencia significativa con respecto a las bibliotecas de colores genéricas: puede establecer colores de forma global o local, manteniendo una sintaxis y un formato de salida consistentes para cada método de consola de Node.js, que luego se utiliza sin tener que especificar los colores, ya que todos se configuran automáticamente .

Tuve que cambiar el color de fondo de la consola a blanco debido a problemas oculares, pero la fuente es de color gris y hace que los mensajes sean ilegibles. ¿Cómo puedo cambiarlo?

Específicamente para su problema, esta es la solución más simple:

var con = require('manakin').global;
con.log.color = 30; // Use black color for console.log

Establecerá un color negro para cada console.logllamada en su aplicación. Ver más códigos de colores .

Colores predeterminados utilizados por manakin :

Sobrecargué los métodos de la consola.

var colors={
Reset: "\x1b[0m",
Red: "\x1b[31m",
Green: "\x1b[32m",
Yellow: "\x1b[33m"
};

var infoLog = console.info;
var logLog = console.log;
var errorLog = console.error;
var warnLog = console.warn;

console.info= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Green);
    copyArgs.push(colors.Reset);
    infoLog.apply(null,copyArgs);
};

console.warn= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Yellow);
    copyArgs.push(colors.Reset);
    warnLog.apply(null,copyArgs);
};
console.error= function(args)
{
    var copyArgs = Array.prototype.slice.call(arguments);
    copyArgs.unshift(colors.Red);
    copyArgs.push(colors.Reset);
    errorLog.apply(null,copyArgs);
};

// examples
console.info("Numeros",1,2,3);
console.warn("pares",2,4,6);
console.error("reiniciandooo");

La salida es.

Encontré esta pregunta y quería usar algunos colores en stdout sin ninguna dependencia. Esto combina algunas de las otras excelentes respuestas aquí.

Esto es lo que tengo. (Requiere el nodo v4 o superior)

// colors.js
const util = require('util')

function colorize (color, text) {
  const codes = util.inspect.colors[color]
  return `\x1b[${codes[0]}m${text}\x1b[${codes[1]}m`
}

function colors () {
  let returnValue = {}
  Object.keys(util.inspect.colors).forEach((color) => {
    returnValue[color] = (text) => colorize(color, text)
  })
  return returnValue
}

module.exports = colors()

Solo necesita el archivo, luego úselo así:

const colors = require('./colors')
console.log(colors.green("I'm green!"))

Los códigos de color predefinidos están disponibles aquí.

consola de pintura

Registro colorable simple. Soporte inspeccionar objetos y actualización de una sola línea Este paquete solo vuelve a pintar la consola.

Instalar en pc

npm install paint-console

uso

require('paint-console');

console.info('console.info();');
console.warn('console.warn();');
console.error('console.error();');
console.log('console.log();');

manifestación

No quiero ninguna dependencia para esto y solo esto funcionó para mí en OS X. Todos los otros ejemplos de respuestas aquí me dieron Octal literalerrores.

Reset = "\x1b[0m"
Bright = "\x1b[1m"
Dim = "\x1b[2m"
Underscore = "\x1b[4m"
Blink = "\x1b[5m"
Reverse = "\x1b[7m"
Hidden = "\x1b[8m"

FgBlack = "\x1b[30m"
FgRed = "\x1b[31m"
FgGreen = "\x1b[32m"
FgYellow = "\x1b[33m"
FgBlue = "\x1b[34m"
FgMagenta = "\x1b[35m"
FgCyan = "\x1b[36m"
FgWhite = "\x1b[37m"

BgBlack = "\x1b[40m"
BgRed = "\x1b[41m"
BgGreen = "\x1b[42m"
BgYellow = "\x1b[43m"
BgBlue = "\x1b[44m"
BgMagenta = "\x1b[45m"
BgCyan = "\x1b[46m"
BgWhite = "\x1b[47m"

fuente: https://coderwall.com/p/yphywg/printing-colorful-text-in-terminal-when-run-node-js-script

Encontré esta respuesta anterior ( https://stackoverflow.com/a/41407246/4808079 ) muy útil, pero incompleta. Si alguna vez quisiste colorear algo una vez, creo que estaría bien, pero creo que compartirlo en una forma funcional ejecutable es mucho más aplicable a los casos de uso de la vida real.

const Color = {
  Reset: "\x1b[0m",
  Bright: "\x1b[1m",
  Dim: "\x1b[2m",
  Underscore: "\x1b[4m",
  Blink: "\x1b[5m",
  Reverse: "\x1b[7m",
  Hidden: "\x1b[8m",

  FgBlack: "\x1b[30m",
  FgRed: "\x1b[31m",
  FgGreen: "\x1b[32m",
  FgYellow: "\x1b[33m",
  FgBlue: "\x1b[34m",
  FgMagenta: "\x1b[35m",
  FgCyan: "\x1b[36m",
  FgWhite: "\x1b[37m",

  BgBlack: "\x1b[40m",
  BgRed: "\x1b[41m",
  BgGreen: "\x1b[42m",
  BgYellow: "\x1b[43m",
  BgBlue: "\x1b[44m",
  BgMagenta: "\x1b[45m",
  BgCyan: "\x1b[46m",
  BgWhite: "\x1b[47m"
}

function colorString(color, string) {
  return `${color}${string}${Color.Reset}`;
}

function colorStringLog(color, string) {
  console.log(colorString(color, string));
}

Úselo así:

colorStringLog(Color.FgYellow, "Some Yellow text to console log");

console.log([
  colorString(Color.FgRed, "red"),
  colorString(Color.FgGreen, "green"),
  colorString(Color.FgBlue, "blue"),
].join(", "));

logger / index.js

const colors = {
    Reset : "\x1b[0m",
    Bright : "\x1b[1m",
    Dim : "\x1b[2m",
    Underscore : "\x1b[4m",
    Blink : "\x1b[5m",
    Reverse : "\x1b[7m",
    Hidden : "\x1b[8m",

    FgBlack : "\x1b[30m",
    FgRed : "\x1b[31m",
    FgGreen : "\x1b[32m",
    FgYellow : "\x1b[33m",
    FgBlue : "\x1b[34m",
    FgMagenta : "\x1b[35m",
    FgCyan : "\x1b[36m",
    FgWhite : "\x1b[37m",

    BgBlack : "\x1b[40m",
    BgRed : "\x1b[41m",
    BgGreen : "\x1b[42m",
    BgYellow : "\x1b[43m",
    BgBlue : "\x1b[44m",
    BgMagenta : "\x1b[45m",
    BgCyan : "\x1b[46m",
    BgWhite : "\x1b[47m",
};

module.exports = () => {
    Object.keys(colors).forEach(key => {
        console['log' + key] = (strg) => {
            if(typeof strg === 'object') strg = JSON.stringify(strg, null, 4);
            return console.log(colors[key]+strg+'\x1b[0m');
        }
    });
}

app.js

require('./logger')();

Luego úsalo como:

console.logBgGreen(" grüner Hintergrund ")

Esto depende un poco de la plataforma en la que se encuentre. La forma más común de hacerlo es imprimiendo secuencias de escape ANSI. Para un ejemplo simple, aquí hay un código de Python de los scripts de compilación de Blender:

// This is a object for use ANSI escape to color the text in the terminal
const bColors = {
    HEADER    : '\033[95m',
    OKBLUE    : '\033[94m',
    OKGREEN   : '\033[92m',
    WARNING   : '\033[93m',
    FAIL      : '\033[91m',
    ENDC      : '\033[0m', 
    BOLD      : '\033[1m',   
    UNDERLINE : '\033[4m'
}

Para usar un código como este, puedes hacer algo como

console.log(`${bColors.WARNING} My name is sami ${bColors.ENDC}`)

var colorSet = {
    Reset: "\x1b[0m",
    Red: "\x1b[31m",
    Green: "\x1b[32m",
    Yellow: "\x1b[33m",
    Blue: "\x1b[34m",
    Magenta: "\x1b[35m"
};

var funcNames = ["info", "log", "warn", "error"];
var colors = [colorSet.Green, colorSet.Blue, colorSet.Yellow, colorSet.Red];

for (var i = 0; i < funcNames.length; i++) {
    let funcName = funcNames[i];
    let color = colors[i];
    let oldFunc = console[funcName];
    console[funcName] = function () {
        var args = Array.prototype.slice.call(arguments);
        if (args.length) {
            args = [color + args[0]].concat(args.slice(1), colorSet.Reset);
        }
        oldFunc.apply(null, args);
    };
}

// Test:
console.info("Info is green.");
console.log("Log is blue.");
console.warn("Warn is orange.");
console.error("Error is red.");
console.info("--------------------");
console.info("Formatting works as well. The number = %d", 123);

También puedes usar colorworks .

Uso:

var cw = require('colorworks').create();
console.info(cw.compile('[[red|Red message with a [[yellow|yellow]] word.]]'));

Para hacer la vida más fácil, también puedes hacer una función con ella.

function say(msg) {
  console.info(cw.compile(msg));
}

Ahora puedes hacer:

say(`[[yellow|Time spent: [[green|${time}]]ms.]]`);

Coolors

Es bastante bueno para usar o extender. Puedes usar simplemente:

var coolors = require('coolors');
console.log(coolors('My cool console log', 'red'));

O con config:

var coolors = require('coolors');
console.log(coolors('My cool console log', {
   text: 'yellow',
   background: 'red',
   bold: true,
   underline: true,
   inverse: true,
   strikethrough: true
}));

Y parece realmente divertido de extender:

var coolors = require('coolors');
function rainbowLog(msg){
    var colorsText = coolors.availableStyles().text;
    var rainbowColors = colorsText.splice(3);
    var lengthRainbowColors = rainbowColors.length;
    var msgInLetters = msg.split('');
    var rainbowEndText = '';
    var i = 0;
    msgInLetters.forEach(function(letter){
        if(letter != ' '){
            if(i === lengthRainbowColors) i = 0;
            rainbowEndText += coolors(letter, rainbowColors[i]);
            i++;
        }else{
            rainbowEndText += ' ';
        }
    });
    return rainbowEndText;
}
coolors.addPlugin('rainbow', rainbowLog);
console.log(coolorsExtended('This its a creative example extending core with a cool rainbown style', 'rainbown'));

Ver módulo de refrigeradores

Creé mi propio módulo, StyleMe . Lo hice para poder hacer mucho con poca escritura. Ejemplo:

var StyleMe = require('styleme');
StyleMe.extend() // extend the string prototype

console.log("gre{Hello} blu{world}!".styleMe()) // Logs hello world! with 'hello' being green, and 'world' being blue with '!' being normal.

También se puede anidar:

console.log("This is normal red{this is red blu{this is blue} back to red}".styleMe())

O, si no desea extender el prototipo de cadena, puede usar cualquiera de las otras 3 opciones:

console.log(styleme.red("a string"))
console.log("Hello, this is yellow text".yellow().end())
console.log(styleme.style("some text","red,bbl"))

En ubuntu puedes simplemente usar códigos de colores:

var sys = require('sys');
process.stdout.write("x1B[31m" + your_message_in_red + "\x1B[0m\r\n");

color-nodo

Proporciona funciones para imprimir textos en color y también para formatear textos como negrita, parpadeo, etc.

Realmente me gustó la respuesta de @ Daniel, pero las funciones console.log {color} no funcionaron de la misma manera que la consola regular. He realizado algunos cambios, y ahora todos los parámetros de las nuevas funciones se pasarán a console.log (así como los códigos de color).

const _colors = {
    Reset : "\x1b[0m",
    Bright : "\x1b[1m",
    Dim : "\x1b[2m",
    Underscore : "\x1b[4m",
    Blink : "\x1b[5m",
    Reverse : "\x1b[7m",
    Hidden : "\x1b[8m",

    FgBlack : "\x1b[30m",
    FgRed : "\x1b[31m",
    FgGreen : "\x1b[32m",
    FgYellow : "\x1b[33m",
    FgBlue : "\x1b[34m",
    FgMagenta : "\x1b[35m",
    FgCyan : "\x1b[36m",
    FgWhite : "\x1b[37m",

    BgBlack : "\x1b[40m",
    BgRed : "\x1b[41m",
    BgGreen : "\x1b[42m",
    BgYellow : "\x1b[43m",
    BgBlue : "\x1b[44m",
    BgMagenta : "\x1b[45m",
    BgCyan : "\x1b[46m",
    BgWhite : "\x1b[47m",
};

const enableColorLogging = function(){
    Object.keys(_colors).forEach(key => {
        console['log' + key] = function(){
            return console.log(_colors[key], ...arguments, _colors.Reset);
        }
    });
}

2017:

De manera simple, agregando color de tiempo al mensaje, no necesita cambiar su código, use keep your console.log ('msg') o console.err ('error')

var clc = require("cli-color");
var mapping = {
  log: clc.blue,
  warn: clc.yellow,
  error: clc.red
};

["log", "warn", "error"].forEach(function(method) {
  var oldMethod = console[method].bind(console);
  console[method] = function() {
    oldMethod.apply(
      console,
      [mapping[method](new Date().toISOString())]
      .concat(arguments)
    );
  };
});

Si está utilizando Windows CMD, vaya a Propiedades / colores del terminal (CMD arriba a la izquierda) y luego redefina el valor RGB del color ofensivo. En mi caso, creo que es el quinto cuadrado de color desde la izquierda, que cambié a (222,222,222). No importa si el botón de opción seleccionado actualmente muestra Texto de pantalla o Fondo de pantalla, ya que simplemente redefine ese color específico del "sistema". Una vez que haya cambiado el color, no olvide volver a seleccionar el color preferido para el fondo o el texto antes de hacer clic en Aceptar.

Después del cambio, todos estos mensajes rojizos de Node (Ember en mi caso) son claramente visibles.

Este es un enfoque para Windows 10 (tal vez para 7) y cambia el esquema de color (tema) para cmd, terminal npm en sí, no solo la salida de la consola para una aplicación en particular.

Encontré el complemento de Windows en funcionamiento: Color Tool , que presumiblemente se desarrolla bajo el paraguas de Windows. Una descripción está disponible en el enlace .

Agregué el directorio colortool a la variable de ruta del entorno del sistema y ahora está disponible cada vez que inicio el terminal (símbolo del sistema NodeJs, cmd).