nodemon

nodemon is a tool that helps develop Node.js based applications by automatically restarting the node application when file changes in the directory are detected.

nodemon doesnotrequireanyadditional changes to your code or method of development. nodemon is a replacement wrapper fornode.To usenodemon,replace the wordnodeon the command line when executing your script.

Installation

Either through cloning with git or by usingnpm(the recommended way):

npm install -g nodemon#or using yarn: yarn global add nodemon

And nodemon will be installed globally to your system path.

You can also install nodemon as a development dependency:

npm install --save-dev nodemon#or using yarn: yarn add nodemon -D

With a local installation, nodemon will not be available in your system path or you can't use it directly from the command line. Instead, the local installation of nodemon can be run by calling it from within an npm script (such asnpm start) or usingnpx nodemon.

Usage

nodemon wraps your application, so you can pass all the arguments you would normally pass to your app:

nodemon [your node app]

For CLI options, use the-h(or--help) argument:

nodemon -h

Using nodemon is simple, if my application accepted a host and port as the arguments, I would start it as so:

nodemon./server.js localhost 8080

Any output from this script is prefixed with[nodemon],otherwise all output from your application, errors included, will be echoed out as expected.

You can also pass theinspectflag to node through the command line as you would normally:

nodemon --inspect./server.js 80

If you have apackage.jsonfile for your app, you can omit the main script entirely and nodemon will read thepackage.jsonfor themainproperty and use that value as the app (ref).

nodemon will also search for thescripts.startproperty inpackage.json(as of nodemon 1.1.x).

Also check out theFAQorissuesfor nodemon.

Automatic re-running

nodemon was originally written to restart hanging processes such as web servers, but now supports apps that cleanly exit. If your script exits cleanly, nodemon will continue to monitor the directory (or directories) and restart the script if there are any changes.

Manual restarting

Whilst nodemon is running, if you need to manually restart your application, instead of stopping and restart nodemon, you can typerswith a carriage return, and nodemon will restart your process.

Config files

nodemon supports local and global configuration files. These are usually namednodemon.jsonand can be located in the current working directory or in your home directory. An alternative local configuration file can be specified with the--config <file>option.

The specificity is as follows, so that a command line argument will always override the config file settings:

• command line arguments
• local config
• global config

A config file can take any of the command line arguments as JSON key values, for example:

{
"verbose":true,
"ignore":["*.test.js","**/fixtures/**"],
"execMap":{
"rb":"ruby",
"pde":"processing --sketch={{pwd}} --run"
}
}

The abovenodemon.jsonfile might be my global config so that I have support for ruby files and processing files, and I can runnodemon demo.pdeand nodemon will automatically know how to run the script even though out of the box support for processing scripts.

A further example of options can be seen insample-nodemon.md

package.json

If you want to keep all your package configurations in one place, nodemon supports usingpackage.jsonfor configuration. Specify the config in the same format as you would for a config file but undernodemonConfigin thepackage.jsonfile, for example, take the followingpackage.json:

{
"name":"nodemon",
"homepage":"http://nodemon.io",
"...":"... other standard package.json values",
"nodemonConfig":{
"ignore":["**/test/**","**/docs/**"],
"delay":2500
}
}

Note that if you specify a--configfile or provide a localnodemon.jsonanypackage.jsonconfig is ignored.

This section needs better documentation, but for now you can also seenodemon --help config(also here).

Using nodemon as a module

Please seedoc/requireable.md

Using nodemon as child process

Please seedoc/events.md

Running non-node scripts

nodemon can also be used to execute and monitor other programs. nodemon will read the file extension of the script being run and monitor that extension instead of.jsif there's nonodemon.json:

nodemon --exec"python -v"./app.py

Now nodemon will runapp.pywith python in verbose mode (note that if you're not passing args to the exec program, you don't need the quotes), and look for new or modified files with the.pyextension.

Default executables

Using thenodemon.jsonconfig file, you can define your own default executables using theexecMapproperty. This is particularly useful if you're working with a language that isn't supported by default by nodemon.

To add support for nodemon to know about the.plextension (for Perl), thenodemon.jsonfile would add:

{
"execMap":{
"pl":"perl"
}
}

Now running the following, nodemon will know to useperlas the executable:

nodemon script.pl

It's generally recommended to use the globalnodemon.jsonto add your ownexecMapoptions. However, if there's a common default that's missing, this can be merged in to the project so that nodemon supports it by default, by changingdefault.jsand sending a pull request.

Monitoring multiple directories

By default nodemon monitors the current working directory. If you want to take control of that option, use the--watchoption to add specific paths:

nodemon --watch app --watch libs app/server.js

Now nodemon will only restart if there are changes in the./appor./libsdirectory. By default nodemon will traverse sub-directories, so there's no need in explicitly including sub-directories.

Nodemon also supports unix globbing, e.g--watch './lib/*'.The globbing pattern must be quoted. For advanced globbing,seepicomatchdocumentation,the library that nodemon uses throughchokidar(which in turn uses it throughanymatch).

Specifying extension watch list

By default, nodemon looks for files with the.js,.mjs,.coffee,.litcoffee,and.jsonextensions. If you use the--execoption and monitorapp.pynodemon will monitor files with the extension of.py.However, you can specify your own list with the-e(or--ext) switch like so:

nodemon -e js,pug

Now nodemon will restart on any changes to files in the directory (or subdirectories) with the extensions.js,.pug.

Ignoring files

By default, nodemon will only restart when a.jsJavaScript file changes. In some cases you will want to ignore some specific files, directories or file patterns, to prevent nodemon from prematurely restarting your application.

This can be done via the command line:

nodemon --ignore lib/ --ignore tests/

Or specific files can be ignored:

nodemon --ignore lib/app.js

Patterns can also be ignored (but be sure to quote the arguments):

nodemon --ignore'lib/*.js'

Importantthe ignore rules are patterns matched to the full absolute path, and this determines how many files are monitored. If using a wild card glob pattern, it needs to be used as**or omitted entirely. For example,nodemon --ignore '**/test/**'will work, whereas--ignore '*/test/*'will not.

Note that by default, nodemon will ignore the.git,node_modules,bower_components,.nyc_output,coverageand.sass-cachedirectories andaddyour ignored patterns to the list. If you want to indeed watch a directory likenode_modules,you need tooverride the underlying default ignore rules.

Application isn't restarting

In some networked environments (such as a container running nodemon reading across a mounted drive), you will need to use thelegacyWatch: truewhich enables Chokidar's polling.

Via the CLI, use either--legacy-watchor-Lfor short:

nodemon -L

Though this should be a last resort as it will poll every file it can find.

Delaying restarting

In some situations, you may want to wait until a number of files have changed. The timeout before checking for new file changes is 1 second. If you're uploading a number of files and it's taking some number of seconds, this could cause your app to restart multiple times unnecessarily.

To add an extra throttle, or delay restarting, use the--delaycommand:

nodemon --delay 10 server.js

For more precision, milliseconds can be specified. Either as a float:

nodemon --delay 2.5 server.js

Or using the time specifier (ms):

nodemon --delay 2500ms server.js

The delay figure is number of seconds (or milliseconds, if specified) to delay before restarting. So nodemon will only restart your app the given number of seconds after thelastfile change.

If you are setting this value innodemon.json,the value will always be interpreted in milliseconds. E.g., the following are equivalent:

nodemon --delay 2.5

{
"delay":2500
}

Gracefully reloading down your script

It is possible to have nodemon send any signal that you specify to your application.

nodemon --signal SIGHUP server.js

Your application can handle the signal as follows.

process.on("SIGHUP",function(){
reloadSomeConfiguration();
process.kill(process.pid,"SIGTERM");
})

Please note that nodemon will send this signal to every process in the process tree.

If you are usingcluster,then each workers (as well as the master) will receive the signal. If you wish to terminate all workers on receiving aSIGHUP,a common pattern is to catch theSIGHUPin the master, and forwardSIGTERMto all workers, while ensuring that all workers ignoreSIGHUP.

if(cluster.isMaster){
process.on("SIGHUP",function(){
for(constworkerofObject.values(cluster.workers)){
worker.process.kill("SIGTERM");
}
});
}else{
process.on("SIGHUP",function(){})
}

Controlling shutdown of your script

nodemon sends a kill signal to your application when it sees a file update. If you need to clean up on shutdown inside your script you can capture the kill signal and handle it yourself.

The following example will listen once for theSIGUSR2signal (used by nodemon to restart), run the clean up process and then kill itself for nodemon to continue control:

// important to use `on` and not `once` as nodemon can re-send the kill signal
process.on('SIGUSR2',function(){
gracefulShutdown(function(){
process.kill(process.pid,'SIGTERM');
});
});

Note that theprocess.killisonlycalled once your shutdown jobs are complete. Hat tip toBenjie Gillamfor writing this technique up.

Triggering events when nodemon state changes

If you want growl like notifications when nodemon restarts or to trigger an action when an event happens, then you can eitherrequirenodemon or add event actions to yournodemon.jsonfile.

For example, to trigger a notification on a Mac when nodemon restarts,nodemon.jsonlooks like this:

{
"events":{
"restart":"osascript -e 'display notification\ "app restarted\ "with title\ "nodemon\ "'"
}
}

A full list of available events is listed on theevent states wiki.Note that you can bind to both states and messages.

Pipe output to somewhere else

nodemon({
script:...,
stdout:false// important: this tells nodemon not to output to console
}).on('readable',function(){// the `readable` event indicates that data is ready to pick up
this.stdout.pipe(fs.createWriteStream('output.txt'));
this.stderr.pipe(fs.createWriteStream('err.txt'));
});

Using nodemon in your gulp workflow

Check out thegulp-nodemonplugin to integrate nodemon with the rest of your project's gulp workflow.

Using nodemon in your Grunt workflow

Check out thegrunt-nodemonplugin to integrate nodemon with the rest of your project's grunt workflow.

Pronunciation

nodemon, is it pronounced: node-mon, no-demon or node-e-mon (like pokémon)?

Well...I've been asked this many times before. I like that I've been asked this before. There's been bets as to which one it actually is.

The answer is simple, but possibly frustrating. I'm not saying (how I pronounce it). It's up to you to call it as you like. All answers are correct:)

Design principles

• Fewer flags is better
• Works across all platforms
• Fewer features
• Let individuals build on top of nodemon
• Offer all CLI functionality as an API
• Contributions must have and pass tests

Nodemon is not perfect, and CLI arguments has sprawled beyond where I'm completely happy, but perhaps it can be reduced a little one day.

FAQ

See theFAQand please add your own questions if you think they would help others.

Backers

Thank you to allour backers!🙏

Sponsors

Support this project by becoming a sponsor. Your logo will show up here with a link to your website.Sponsor this project today ❤️

Please note that links to the sponsors above are not direct endorsements nor affiliated with any of contributors of the nodemon project.

License

MIThttp://rem.mit-license.org