Node.js Console/Debugger for Windows

Question

I am looking for nice console alternative to use with Node.js. I am currently using Console2 but I want some expand/collapse handles when console.log'ing javascript objects; Just like any modern web browser console has (Webkit, Chrome for example).

A remote solution is acceptable. Like a webkit console window remotely connected to a cmd console session.

Must Haves:

• Collapsible(expand/collapse) objects (and arrays...)
• Supports colored text goodness
• Works as a normal console (like Windows cmd). up-arrow, etc
• Supports copy(ctrl+c), paste(ctrl+v) key shortcuts

Nice to Haves:

• Supports console.group and other console methods.
• Full key binding options

---

Projects I have found:

• UltraREPL's readme says that collapsible objects are "In Progress".
• Node Inspector which I thought was perfect but turns out their console is just a REPL client that doesn't print the console.log STDOUT calls in scripts. Node Inspector is really just for inspecting variables and adding breakpoints.
• Chrome Logger is the closest so far but you need a response object to piggyback which makes this very unusable if you aren't using node as a web server.

Other Questions:

• Output to Chrome console from Node.js

Answer 1

devtool: npm install devtool -g

Runs Node.js programs inside Chrome DevTools (using Electron).

This allows you to profile, debug and develop typical Node.js programs with some of the features of Chrome DevTools.

Use the devtool command in place of node: devtool myscript.js

NodeMonkey: npm install node-monkey

It captures anything that would normally be logged to the terminal, [...] and passes it to the browser where it is then logged to the console for inspection.

This uses Chrome's(webkit) actual built-in Developer Tools Javascript console for output.

1. Include NodeMonkey in your script: var nomo = require('node-monkey').start({port: 50501});
2. Open up http://127.0.0.1:50501 and inspect element, etc to open up the developer console.
3. Then run your script as normal: node myscript.js

One nice thing about NodeMonkey(and node-codein suggested below), is that you can leave up the developer console(no refreshes) everytime you make a change and restart the script, NodeMonkey just continues to listen.

Another thing NodeMonkey has is locations(path, line number, and column), so you know where the message came from (see image below).

I prefer NodeMonkey because it uses the awesome Chrome developer console. Update: devtool is looking to be my new choice.

---

Iron Node

Debug Node.js code with Chrome Developer Tools on Linux, Windows and OS X.

---

Inspecting Node.js with Chrome DevTools

This is still in development but you can watch the progress on nodejs/node#2546

The goal is to provide a "unified debugger support across various v8 embedders".

What we aim for Node is what we have for Chrome for Android. You basically go to chrome://inspect on a stable version of Chrome and it debugs your running Node instance.

---

Mancy: npm install mancy -g

A cross platform NodeJS REPL application based on electron and react frameworks.

---

node-codein: npm install node-codein

Even though this tool uses the Chrome executable, it does not use the Chrome/Webkit inspector console for output. Instead it uses its own proprietary/special console which feels a bit chintzy.

1. Include codein in your script: var codein = require("node-codein");
2. Run path/to/chrome/chrome.exe --app=http://localhost:55281 to open the special node-codein console.
3. Then run your script as normal: node myscript.js

---

node-webkit: download build

This is by far the least efficient method to inspect and view console output because of the long list of steps below. node-webkit also has some oddities and changes to the normal Node API which can conflict with your existing libraries or dependencies.

1. Add a HTML file
2. Add the script to debug in a <script src="script-to-debug.js"></script> tag to the HTML file.
3. Update your package.json main attribute to point at the HTML file.
4. Run nw.exe path/to/project_folder/.
5. Then wait for node-webkit window to appear.
6. Click the hamburger icon and wait for th the inspector window (just like Chrome/Webkit) to start, and go the Console tab.
7. Every time you make a change to your script, go through steps 4-6.

You can also use the remote debugging flag, so you can just pop open a chrome tab and visit the page.

1. nw.exe --remote-debugging-port=9222 path/to/project_folder/
2. Visit: http://localhost:9222/

Answer 2

I use Node Webkit for this. It supports most / all (?) of the Chrome debugging protocols; it also emulates the functionality of Chrome Devtools in terms of inspecting collapsible objects and it supports the same console API calls.

You can even load and inspect modules live from the developer console; which is perfect when getting a feel for the node.js modules you will be using.

Another neat feature that I apply when debugging where I know I will be alternating back and forth between the command prompt is that when using ConEmu, you can embed the Node Webkit DevTools Console directly into a tab in ConEmu. It's seamless and doesn't use much CPU. You can even have it as a split tab with the command prompt so you can see both at once.