Nodemon app crashed waiting for file changes before starting как исправить

EDIT
After further testing, I have found that this is happening with both gulp and grunt on this app and on the default install of mean.js. I’m running this locally on a Mac. When I running either app using «node server.js» they don’t crash.

I’m using a MEAN stack with grunt-nodemon and node is crashing when an express URL is accessed. It isn’t always consistent though. Sometimes it works, sometimes node crashes right when the URL is hit retiring no data, and other times I get a response and node crashed immediately after.

Browser console response:

http://localhost:8000/api/users net::ERR_CONNECTION_REFUSED

Terminal output:

Mongoose: users.insert({ firstname: 'mike', lastname: 'jones', email:'mike@gmail.com', role: 'admin', password: 'mike', _id: ObjectId("57485c16fc11894b96c28057"), created: new Date("Fri, 27 May 2016 14:39:18 GMT"), __v: 0 })   
user.save success
node crash
[nodemon] app crashed - waiting for file changes before starting...

In this case, the POST request went through, the user was added, then node crashed, but sometimes it crashes before a successful POST. Node also occasionally crashes on the GET request.

gruntfile.js:

module.exports = function(grunt) {
    // Load grunt tasks automatically
    require('load-grunt-tasks')(grunt);

    var pkg = grunt.file.readJSON('package.json');

    var options = {
        paths: {
            app: 'app',
            assets: 'app/assets',
            dist: 'app/dist',
            distAssets: 'app/dist/assets',
            html: 'app/html',
            htmlTmp: '.tmp/htmlsnapshot',
            htmlAssets: 'app/html/assets',
            index: 'app/dist/index.html',
            indexDev: 'app/index.html',
            indexTmp: '.tmp/html/index.html'
        },
        pkg: pkg,
        env: {
            test: {
                NODE_ENV: 'test'
            },
            dev: {
                NODE_ENV: 'development'
            },
            prod: {
                NODE_ENV: 'production'
            }
        }
    };

    // Load grunt configurations automatically
    var configs = require('load-grunt-configs')(grunt, options);

    // Define the configuration for all the tasks
    grunt.initConfig(configs);

    // Connect to the MongoDB instance and load the models
    grunt.task.registerTask('mongoose', 'Task that connects to the MongoDB instance and loads the application models.', function () {
        // Get the callback
        var done = this.async();

        // Use mongoose configuration
        var mongoose = require('./config/lib/mongoose.js');

        // Connect to database
        mongoose.connect(function (db) {
            done();
        });
    });

    grunt.registerTask('bumper', ['bump-only']);
    grunt.registerTask('css', ['sass']);
    grunt.registerTask('default', [
        'sass',
        'copy:dev',
        'nodemon',
        'concurrent:dev',
        'watch',
        'mongoose'
    ]);

    grunt.registerTask('shared', [
        'clean:demo',
        'copy:demo',
        'sass',
        'ngconstant',
        'useminPrepare',
        'concat:generated',
        'cssmin:generated',
        'uglify:generated',
        'filerev',
        'usemin',
        'imagemin',
        'usebanner'
    ]);

    grunt.registerTask('demo', [
        'shared',
        'copy:postusemin',
        'grep:demo'
    ]);

    grunt.registerTask('dist', [
        'shared',
        'copy:postusemin',
        'copy:dist',
        'grep:dist',
        'compress',
        'copy:postusemin',
        'grep:demo',
    ]);

    grunt.loadNpmTasks('grunt-forever');

};

default.js

module.exports.tasks = {
    // version update
    bump: {
        options: {
            files: ['package.json', 'bower.json'],
            pushTo: 'origin'
        }
    },

    // application constants
    ngconstant: {
        options: {
            dest: '<%= paths.assets %>/js/app.constants.js',
            name: 'app.constants',
        }
    },

    // remove all bs from css
    cssmin: {
        options: {
            keepSpecialComments: 0
        }
    },
    markdown: {
        all: {
            files: [
                {
                    src: 'README.md',
                    dest: '<%= paths.assets %>/tpl/documentation.html'
                }
            ],
            options: {
                template: '<%= paths.assets %>/tpl/_documentation_template.html',
            }
        }
    }
};

dev.js:

var _ = require('lodash'),
defaultAssets = require('./assets/default'),
testAssets = require('./assets/test'),
testConfig = require('./env/test'),
fs = require('fs'),
path = require('path');

module.exports.tasks = {
    // copy files to correct folders
    copy: {
        dev: {
            files: [
                { expand: true, src: '**', cwd: '<%= paths.app %>/bower_components/font-awesome/fonts',                    dest: '<%= paths.assets %>/fonts' },
                { expand: true, src: '**', cwd: '<%= paths.app %>/bower_components/material-design-iconic-font/fonts',     dest: '<%= paths.assets %>/fonts' },
                { expand: true, src: '**', cwd: '<%= paths.app %>/bower_components/roboto-fontface/fonts',                 dest: '<%= paths.assets %>/fonts' },
                { expand: true, src: '**', cwd: '<%= paths.app %>/bower_components/weather-icons/font',                    dest: '<%= paths.assets %>/fonts' },
                { expand: true, src: '**', cwd: '<%= paths.app %>/bower_components/bootstrap-sass/assets/fonts/bootstrap', dest: '<%= paths.assets %>/fonts' }
            ]
        }
    },

    // watch for changes during development
    watch: {
        js: {
            files: ['Gruntfile.js', '<%= paths.assets %>/js/**/*.js'],
            tasks: ['jshint'],
            options: {
                livereload: true
            }
        },
        css: {
            files: [
                '<%= paths.assets %>/css/**/*.scss'
            ],
            tasks: ['sass'],
            options: {
                livereload: true
            }
        },
        markdown: {
            files: [
                'README.md'
            ],
            tasks: ['markdown']
        },
        tasks:  [ 'express:dev' ],
    },

    // debug while developing
    jshint: {
        all: ['Gruntfile.js', '<%= paths.assets %>/js/**/*.js']
    },
    concurrent: {
        dev: {
            tasks: ['nodemon', 'node-inspector', 'watch'],
            options: {
                logConcurrentOutput: true
            }
        }
    },
    nodemon: {
        dev: {
            script: 'server.js',
            options: {
                nodeArgs: ['--debug'],
                ext: 'js,html',
                callback: function (nodemon) {

                    nodemon.on('crash', function (event) {
                        console.log(event);
                    });


                },
                watch: _.union(defaultAssets.server.gruntConfig, defaultAssets.server.views, defaultAssets.server.allJS, defaultAssets.server.config)
            }
        }
    },
    forever: {
        server1: {
            options: {
                index: 'server.js',
                //logDir: 'logs'
            }
        }
    }
};

Angular controller function:

  $scope.addUser = function(){

      var user = {
          firstname: $scope.firstname,
          lastname: $scope.lastname,
          email: $scope.email,
          role: $scope.role.selected,
          password: $scope.password
      };

      $http.post('/api/userAdd', user ).then(function successCallback(response) {
          $location.path('/users');
      }, function errorCallback(response) {
          console.log('error addding user');
          console.log(response);
      });
  };

Express route:

User = require('../models/user.js');

module.exports = function (app) {

    app.get('/api/users', function (req, res) {

        User.find({}, function (err, users) {
            if ( err ) {
                res.send({
                    message : 'error finding users',
                    success: false
                });
            } else {
                res.json(users);
            }
        });

    });

    app.get('/api/users', function (req, res) {
        User.find({fields: {}}, function (err, docs) {
            res.json(docs);
        });
    });

    app.post('/api/userAdd', function (req, res) {

        var user = new User(req.body);

        user.save( function( err, user ){

            if (err){
                console.log('user.save error');
                console.log(err);
                res.send({
                    success: false
                });
            } else {
                console.log('user.save success');
                res.send({
                    success: true
                });
            }
        });

    });

};

I’m also testing with Chromes Advanced REST extension and with any request using this tool node crashes immediately.

I’m new to MEAN so am I missing something here that is causing the crash? Any ideas?

Nodemon is not something new to the world of programming as it is one of the tools that are used to develop applications that are based on node.js. When using a nodemon, the node should be replaced with the nodemon in the command at the time of running the script. An error ‘[nodemon] app crashed – waiting for file changes before starting’ pops up when you are working on the nodemon.

This error seems annoying when you get it after executing a long script. Let’s have look at the error that you may get

When you are trying to execute a program using nodemon, you land yourself up in the error. This is how you get the error

Mongoose: users.insert({ firstname: 'firstname', lastname: 'lastname', email:'[email protected]', role: 'admin', password: 'nick', _id: ObjectId("57485c16fc11894b96c28356"), created: new Date("Thu, 13 Oct 2016 15:40:17 GMT"), __v: 0 }) 
 user.save success
 node crash
 [nodemon] app crashed - waiting for file changes before starting...

You can also get a browser console response like this:

http://localhost:8000/api/users net::ERR_CONNECTION_REFUSED

That’s how you experience the ‘[nodemon] app crashed – waiting for file changes before starting’ error.

Solutions to Fix the “[nodemon] app crashed – waiting for file changes before starting” Error

Check the solutions to get rid of the error

Solution 1 – Kill node process

The error occurs because of the server processes running in the background. To avoid the error, you have to close the terminal. Some programmers use Linux while many use Windows operating system. Let’s discuss see how you can solve the error

For Linux

When working with Linux, every time you get the error, you need to use the below command to close the terminal

Once done, you just need to restart the nodemon to make it work.

For Windows

If you are a Windows user, then you need to follow the below code

1. Go to the task manager
 2. Then look for Node.js: Server-side JavaScript
 3. Then right click on it and End task from the processes.

To make it work perfectly, you need to restart the nodemon.

This solution can fix the ‘[nodemon] app crashed – waiting for file changes before starting’ error.

Solution 2 – the Package.json and server.js are not in the same folder

Make sure the Package.json and server.js are not in the same folder as it can cause the error warning. In order to check the file, follow the code

"scripts": {
    "test": "echo "Error: no test specified" && exit 1",
     "start": "nodemon Server.js"
 }

Solution 3 – Check for syntax error

The JavaScript syntax error or typing mistake can also be the reason you get an error when compiling. To solve the issue, you need to first check for the syntax by validating, and then to troubleshoot, use the command to debug or run the server manually.

For debugging

For running the server manually

$ sudo node server.js

or

$ sudo node index.js

Conclusion

And that’s how to tackle the ‘[nodemon] app crashed – waiting for file changes before starting’ error.  I hope you find it useful!

I wish you all the best!

The nodemon app crashed waiting for file changes before starting and compromised your programming experience due to several running node JS processes. Due to this reason, your program shows the nodemon app crashed message and terminates the program, although the nodemon Daemon is fully functional and responsive.

However, you are at the best place to learn how to repair the nodemon app crashed – waiting for file changes before starting on Mac using the most simple yet effective debugging approaches and solutions.

In addition, this profound guide teaches how to recreate the nodemon restart without changes, which is essential before changing the elements and values in your nodemon app.

The nodemon app crashed – waiting for file changes before starting… VSCode due to multiple running node processes at the same time in the background. In addition, your system will encounter this broken exception when the JS package and server are not in the same folder.

For instance, the [nodemon] clean exit – waiting for changes before restart code exception is inevitable when running many node processes in the background. Henceforth, the app crashed, and your system failed to render the inputs regardless of how correct and clean your syntax looks.

Still, this is one of the many culprits for the docker nodemon app crashed – waiting for file changes before starting a warning, especially with complex applications. We also experienced this broken exception when the JS server and package are not in the same folder, confusing your program and displaying the error under consideration.

As a result, checking your document and structure is critical before completing the application to avoid unexpected obstacles and mistakes.

In addition, the bug can occur when forgetting to source your env files, confirming the port 3000 is already in use nodemon app crashed – waiting for file changes before starting.

However, we will reproduce the nodemon app crashed no error message to help you troubleshoot the program and pinpoint the failed procedures. Furthermore, you can compare the real-life examples to your document, which should help you locate the running code processes and commands.

– Multiple Active Server Processes in the Background

This guide’s first broken script runs an application using a JS node server on Mac. Although the procedure sounds straightforward and no mistakes should occur, the system experiences obstacles due to the active server processes in the background.

As a result, we will exemplify the terminal output and JS grunt file to confirm the inconsistencies.

The following example provides the terminal output:

This code snippet confirms the flaws and terminates the program due to the running node processes. However, the example is only complete after providing the JS grunt file exporting the modules.

The following syntax provides this file:

Still, this is one of the many examples of forcing your system to fail.

– Creating an Express Route With Angular Controller Functions

Due to the active server processes, we can recreate the error log when creating an express route with Angular controller functions.

Although this instance rarely affects advanced projects and applications, it can happen when you expect the least. Therefore, we will exemplify the express route and Angular controller functions to capture the error’s root.

The following example provides the express route:

Although most functions and commands appear functional, the system displays an exception. However, we can complete the invalid procedure by exemplifying the Angular script, as shown in the following example:

Remember to compare the processes to your document to troubleshoot the program and locate the broken procedures. This also helps with the debugging methods, as you will soon learn.

How To Fix the Nodemon App That Crashed Waiting for File Changes Bug?

You can fix the nodemon app that crashes code exceptions by checking and shutting down all irrelevant running node processes. In addition, you can overcome the error log by ensuring the JS package and server files are in the same folder, which is critical for your program.

This section confirms the debugging approaches only take a minute to implement and do not affect other functions and elements. In addition, they work for all applications regardless of commands and processes.

Considering that, we will teach you how to check and kill the irrelevant running node processes. The debugging steps differ for Linux and Windows, so we will cover both.

The following list debugs your Linux operating system:

1. Search for id node processes and take note. Use the following command line to start the procedure: $ ps aux | grep -i node
2. You must use this command to shut down the irrelevant running processes: $ sudo kill -9 [Process-ID]
3. Alternatively, use the following method to kill specific ports: sudo lsof -i :3000 //replace 3000 with your port number, and sudo kill -9 31363 // replace 31363 with your PID

This solution works for all Linux systems, and you should avoid severe obstacles. Still, use the following list to repair your Windows project:

1. Open the Task Manager by clicking the taskbar.
2. Check the list for these processes: Node.js: Server-side JavaScript.
3. Select the procedure and click the End Task option on the right.

Your program should no longer experience this mistake when making changes to the script.

– Ensure the JS Server and Package Files Are in the Same Folder

The second debugging approach suggests checking if the JS server and package files are in the same folder. This removes the code exception and reenables all procedures in your application.

Use the following code snippet to check both files:

So, your system should indicate the packages are in the same folder by displaying the following visual output:

Your system should no longer experience this code exception after placing the JS server and package files in the same folder.

Conclusion

The nodemon app crashed while waiting for file changes before starting and compromises your programming experience due to several running node JS processes. You can remember this guide’s critical points in the following bullet list:

• The error can happen when the JS package and server are not in the same folder
• We recreated the mistake by running an application using a JS node server on Mac
• Checking and shutting down all irrelevant running node processes is the first solution
• Both debugging techniques from this guide fix all applications regardless of the purpose

This step-by-step guide proved that repairing your program and removing the nodemon exception is simple and takes little time. So, open your program and implement these methods without further ado.