Can a node.js server know if a server file is created?

You should take a look at fs.watch(). It allows you to "watch" a file or directory and receive events when things change.

Note: The documentation states that fs.watch is not consistent across platforms, so you should take that in to account before using it.

fs.watch(fileOrDirectoryPath, function(event, filename) {
    // Something changed with filename, trigger event appropriately
});

Also something to be aware of from the docs:

Providing filename argument in the callback is not supported on every platform (currently it's only supported on Linux and Windows). Even on supported platforms filename is not always guaranteed to be provided. Therefore, don't assume that filename argument is always provided in the callback, and have some fallback logic if it is null.

If filename is not available on your platform and you're watching a directory you may need to do something where you initially read the directory and cache the list of files in it. Then, when you get an event from fs.watch, read the directory again and compare it to the cached list of files to see what was added (if anything).

---

Update 1: There's a good module called watch, on github, which makes it easy to watch a directory for new files.

---

Update 2: I threw together an example of how to use fs.watch to get notified when new files are added to a directory. I think the module I linked to above is probably the better way to go, but I thought it would be nice to have a basic example of how it might work if you were to do it yourself.

Note: This is a fairly simplistic example just to show how it could work in general. It could almost certainly be done more efficiently and it's far from throughly tested.

function watchForNewFiles(directory, callback) {
    // Get a list of all the files in the directory
    fs.readdir(directory, function(err, files) {
        if (err) {
            callback(err);
        } else {
            var originalFiles = files;

            // Start watching the directory for new events
            var watcher = fs.watch(directory, function(event, filename) {
                // Get the updated list of all the files in the directory
                fs.readdir(directory, function(err, files) {
                    if (err) {
                        callback(err);
                    } else {
                        // Filter out any files we already knew about
                        var newFiles = files.filter(function(f) {
                            return (originalFiles.indexOf(f) < 0);
                        });

                        // Reset our list of "original" files
                        originalFiles = files;

                        // If there are new files detected, call the callback
                        if (newFiles.length) {
                            callback(null, newFiles);
                        }
                    }
                })
            });
        }
    });
}

Then, to watch a directory you'd call it with:

watchForNewFiles(someDirectoryPath, function(err, files) {
    if (err) {
        // handle error
    } else {
        // handle any newly added files
        // "files" is an array of filenames that have been added to the directory
    }
});

I came up with my own solution using this code here:

var fs = require('fs');

var intID = setInterval(check,1000);

function check() {
    fs.exists('file.txt', function check(exists) {
        if (exists) {
            console.log("Created!");
            clearInterval(intID);
        }
    });
}

You could add a parameter to the check function with the name of the file and call it in the path.

I did some tests on fs.watch() and it does not work if the file is not created. fs.watch() has multiple issues anyways and I would never suggest using it... It does work to check if the file was deleted though...