imagemagick error on node.js - node.js

I'm getting error like this
node.js:201
throw e; // process.nextTick error, or 'error' event on first tick
^
Error: Command failed: CreateProcessW: The system cannot find the file specified
.
at ChildProcess.<anonymous> (C:\Program Files\nodejs\node_modules\imagemagic
k\imagemagick.js:64:15)
at ChildProcess.emit (events.js:70:17)
at maybeExit (child_process.js:361:16)
at Socket.<anonymous> (child_process.js:466:7)
at Socket.emit (events.js:67:17)
at Array.0 (net.js:320:10)
at EventEmitter._tickCallback (node.js:192:40)
image paths are fine & operations are on node v0.6.11 & Imagemagick v0.1.2
any idea abt problem

Maybe this reply helps someone else...
I edited identify.path and convert.path and worked
var img = require('imagemagick');
im.identify.path = "C:/Program Files/ImageMagick-6.8.2-Q16/identify";
im.convert.path = "C:/Program Files/ImageMagick-6.8.2-Q16/convert";
I don't know if there are a more elegant solution.

Make sure that ImageMagic is installed and available within the environment path. Try to use it from the commandline first, and do the operation yourself, not by using any other node modules.
If it works fine then you can use the child_process.exec() API like this:
var util = require('util'),
exec = require('child_process').exec,
child;
child = exec('cat *.js bad_file | wc -l',
function (error, stdout, stderr) {
console.log('stdout: ' + stdout);
console.log('stderr: ' + stderr);
if (error !== null) {
console.log('exec error: ' + error);
}
});
For more information. Check this Process and Forking API in Node.JS.
One more thing. Don't forget to quote the paths that has spaces and special chars in them before passing them in the command line. This will save you lots of headache and bug hunting.
With the little information you provide this is all I can answer. That's why the answer is not exactly specific to your case. If you need more from this website (SO) you should at least provide enough code and even better complete (i.e. runnable) code that contains only the problematic part.

Did you already isolate the error to a specific codeline?
If not, ok, we got little bit of information for debugging:
The system cannot find the file specified
You already may have a glitch where the problem could be, so go through all I/O operations and try to eliminate one by one. Debug with console.log or your favourite method to find your way through.

Related

How do I debug "Error: spawn ENOENT" on node.js?

When I get the following error:
events.js:72
throw er; // Unhandled 'error' event
^
Error: spawn ENOENT
at errnoException (child_process.js:1000:11)
at Process.ChildProcess._handle.onexit (child_process.js:791:34)
What procedure can I follow to fix it?
Author note: Lots of issues with this error encouraged me to post this question for future references.
Related questions:
using spawn function with NODE_ENV=production
node.js child_process.spawn ENOENT error - only under supervisord
spawn ENOENT node.js error
https://stackoverflow.com/questions/27603713/nodejs-spawn-enoent-error-on-travis-calling-global-npm-package
Node JS - child_process spawn('npm install') in Grunt task results in ENOENT error
Running "foreman" task Fatal error: spawn ENOENT
unhandled error event in node js Error: spawn ENOENT at errnoException (child_process.js:975:11)
Node.js SpookyJS: error executing hello.js
https://stackoverflow.com/questions/26572214/run-grunt-on-a-directory-nodewebkit
Run exe file with Child Process NodeJS
Node: child_process.spawn not working on Java even though it's in the path (ENOENT)
spawn ENOENT error with NodeJS (PYTHON related)
image resizing is not working in node.js (partial.js) (non-installed dependency)
npm install error ENOENT (build dependency problem)
Cannot install node.js - oracle module on Windows 7 (build dependency problem)
Error installing gulp using nodejs on windows (strange case)
NOTE: This error is almost always caused because the command does not exist, because the working directory does not exist, or from a windows-only bug.
I found a particular easy way to get the idea of the root cause of:
Error: spawn ENOENT
The problem of this error is, there is really little information in the error message to tell you where the call site is, i.e. which executable/command is not found, especially when you have a large code base where there are a lot of spawn calls. On the other hand, if we know the exact command that cause the error then we can follow #laconbass' answer to fix the problem.
I found a very easy way to spot which command cause the problem rather than adding event listeners everywhere in your code as suggested in #laconbass' answer. The key idea is to wrap the original spawn call with a wrapper which prints the arguments send to the spawn call.
Here is the wrapper function, put it at the top of the index.js or whatever your server's starting script.
(function() {
var childProcess = require("child_process");
var oldSpawn = childProcess.spawn;
function mySpawn() {
console.log('spawn called');
console.log(arguments);
var result = oldSpawn.apply(this, arguments);
return result;
}
childProcess.spawn = mySpawn;
})();
Then the next time you run your application, before the uncaught exception's message you will see something like that:
spawn called
{ '0': 'hg',
'1': [],
'2':
{ cwd: '/* omitted */',
env: { IP: '0.0.0.0' },
args: [] } }
In this way you can easily know which command actually is executed and then you can find out why nodejs cannot find the executable to fix the problem.
Step 1: Ensure spawn is called the right way
First, review the docs for child_process.spawn( command, args, options ):
Launches a new process with the given command, with command line arguments in args. If omitted, args defaults to an empty Array.
The third argument is used to specify additional options, which defaults to:
{ cwd: undefined, env: process.env }
Use env to specify environment variables that will be visible to the new process, the default is process.env.
Ensure you are not putting any command line arguments in command and the whole spawn call is valid. Proceed to next step.
Step 2: Identify the Event Emitter that emits the error event
Search on your source code for each call to spawn, or child_process.spawn, i.e.
spawn('some-command', [ '--help' ]);
and attach there an event listener for the 'error' event, so you get noticed the exact Event Emitter that is throwing it as 'Unhandled'. After debugging, that handler can be removed.
spawn('some-command', [ '--help' ])
.on('error', function( err ){ throw err })
;
Execute and you should get the file path and line number where your 'error' listener was registered. Something like:
/file/that/registers/the/error/listener.js:29
throw err;
^
Error: spawn ENOENT
at errnoException (child_process.js:1000:11)
at Process.ChildProcess._handle.onexit (child_process.js:791:34)
If the first two lines are still
events.js:72
throw er; // Unhandled 'error' event
do this step again until they are not. You must identify the listener that emits the error before going on next step.
Step 3: Ensure the environment variable $PATH is set
There are two possible scenarios:
You rely on the default spawn behaviour, so child process environment will be the same as process.env.
You are explicity passing an env object to spawn on the options argument.
In both scenarios, you must inspect the PATH key on the environment object that the spawned child process will use.
Example for scenario 1
// inspect the PATH key on process.env
console.log( process.env.PATH );
spawn('some-command', ['--help']);
Example for scenario 2
var env = getEnvKeyValuePairsSomeHow();
// inspect the PATH key on the env object
console.log( env.PATH );
spawn('some-command', ['--help'], { env: env });
The absence of PATH (i.e., it's undefined) will cause spawn to emit the ENOENT error, as it will not be possible to locate any command unless it's an absolute path to the executable file.
When PATH is correctly set, proceed to next step. It should be a directory, or a list of directories. Last case is the usual.
Step 4: Ensure command exists on a directory of those defined in PATH
Spawn may emit the ENOENT error if the filename command (i.e, 'some-command') does not exist in at least one of the directories defined on PATH.
Locate the exact place of command. On most linux distributions, this can be done from a terminal with the which command. It will tell you the absolute path to the executable file (like above), or tell if it's not found.
Example usage of which and its output when a command is found
> which some-command
some-command is /usr/bin/some-command
Example usage of which and its output when a command is not found
> which some-command
bash: type: some-command: not found
miss-installed programs are the most common cause for a not found command. Refer to each command documentation if needed and install it.
When command is a simple script file ensure it's accessible from a directory on the PATH. If it's not, either move it to one or make a link to it.
Once you determine PATH is correctly set and command is accessible from it, you should be able to spawn your child process without spawn ENOENT being thrown.
simply adding shell: true option solved my problem:
incorrect:
const { spawn } = require('child_process');
const child = spawn('dir');
correct:
const { spawn } = require('child_process');
const child = spawn('dir', [], {shell: true});
As #DanielImfeld pointed it, ENOENT will be thrown if you specify "cwd" in the options, but the given directory does not exist.
Windows solution: Replace spawn with node-cross-spawn. For instance like this at the beginning of your app.js:
(function() {
var childProcess = require("child_process");
childProcess.spawn = require('cross-spawn');
})();
For ENOENT on Windows, https://github.com/nodejs/node-v0.x-archive/issues/2318#issuecomment-249355505 fix it.
e.g. replace spawn('npm', ['-v'], {stdio: 'inherit'}) with:
for all node.js version:
spawn(/^win/.test(process.platform) ? 'npm.cmd' : 'npm', ['-v'], {stdio: 'inherit'})
for node.js 5.x and later:
spawn('npm', ['-v'], {stdio: 'inherit', shell: true})
#laconbass's answer helped me and is probably most correct.
I came here because I was using spawn incorrectly.
As a simple example:
this is incorrect:
const s = cp.spawn('npm install -D suman', [], {
cwd: root
});
this is incorrect:
const s = cp.spawn('npm', ['install -D suman'], {
cwd: root
});
this is correct:
const s = cp.spawn('npm', ['install','-D','suman'], {
cwd: root
});
however, I recommend doing it this way:
const s = cp.spawn('bash');
s.stdin.end(`cd "${root}" && npm install -D suman`);
s.once('exit', code => {
// exit
});
this is because then the cp.on('exit', fn) event will always fire, as long as bash is installed, otherwise, the cp.on('error', fn) event might fire first, if we use it the first way, if we launch 'npm' directly.
How to research the spawn call raising the error:
Use NODE_DEBUG=child_process, Credits to #karl-richter. Simple, quick, October 2019
Use a wrapper to decorate child_process.spawn, Credits to #jiaji-zhou. Simple, quick, January 2015
Long procedure, credits to #laconbass. Complex, time-cost, December 2014
Known, usual causes
Environment issues
The command executable does not exist within the system (dependency not being installed). see prominc's answer
The command executable does not exist within a directory of those specified by PATH environment variable.
The executable binary was compiled with uncompatible libraries. see danilo-ramirez answer
Windows-only bugs/quirks
'.cmd' extension / shell: true. see li-zheng answer
Administrator permisions. see steve's answer
Wrong spawn('command', ['--argument', 'list'], { cwd, env, ...opts }) usage
Specified working directory (opts.cwd) does not exist ยท see leeroy-brun's answer
Argument list within command String spawn('command --wrong --argument list')
Env vars within command string spawn('ENV_VAR=WRONG command')
Argument list Array specified as String spawn('cmd', '--argument list')
Unset PATH env variable spawn('cmd', [], { env: { variable } } => spawn('cmd', [], { env: { ...process.env, variable } }
There are 2 posible origins for ENOENT:
Code you are writing
Code you depend on
When origin is code you depend on, usual cause is an Environment Issue (or windows quirk)
For anyone who might stumble upon this, if all the other answers do not help and you are on Windows, know that there is currently a big issue with spawn on Windows and the PATHEXT environment variable that can cause certain calls to spawn to not work depending on how the target command is installed.
In my case, I was getting this error thrown due to the necessary dependent system resources not being installed.
More specifically, I have a NodeJS app that is utilizing ImageMagick. Despite having the npm package installed, the core Linux ImageMagick was not installed. I did an apt-get to install ImageMagick and after that all worked great!
Before anyone spends to much time debugging this problem, most of the time it can be resolved by deleting node_modules and reinstalling the packages.
To Install:
If a lockfile exists you might use
yarn install --frozen-lockfile
or
npm ci
respectivly. if not then
yarn install
or
npm i
Are you changing the env option?
Then look at this answer.
I was trying to spawn a node process and TIL that you should spread the existing environment variables when you spawn else you'll loose the PATH environment variable and possibly other important ones.
This was the fix for me:
const nodeProcess = spawn('node', ['--help'], {
env: {
// by default, spawn uses `process.env` for the value of `env`
// you can _add_ to this behavior, by spreading `process.env`
...process.env,
OTHER_ENV_VARIABLE: 'test',
}
});
In case you're experiencing this issue with an application whose source you cannot modify consider invoking it with the environment variable NODE_DEBUG set to child_process, e.g. NODE_DEBUG=child_process yarn test. This will provide you with information which command lines have been invoked in which directory and usually the last detail is the reason for the failure.
I ran into the same problem, but I found a simple way to fix it.
It appears to be spawn() errors if the program has been added to the PATH by the user (e.g. normal system commands work).
To fix this, you can use the which module (npm install --save which):
// Require which and child_process
const which = require('which');
const spawn = require('child_process').spawn;
// Find npm in PATH
const npm = which.sync('npm');
// Execute
const noErrorSpawn = spawn(npm, ['install']);
Use require('child_process').exec instead of spawn for a more specific error message!
for example:
var exec = require('child_process').exec;
var commandStr = 'java -jar something.jar';
exec(commandStr, function(error, stdout, stderr) {
if(error || stderr) console.log(error || stderr);
else console.log(stdout);
});
A case that I found that is not in this list but it's worthy to be added:
On Alpine Linux, Node will error with ENOENT if the executable is not compatible.
Alpine expects binaries with libc. An executable (e.g. chrome as part of chromium) that has been compiled with glibc as a wrapper for system calls, will fail with ENOENT when called by spawn.
Ensure module to be executed is installed or full path to command if it's not a node module
I was also going through this annoying problem while running my test cases, so I tried many ways to get across it. But the way works for me is to run your test runner from the directory which contains your main file which includes your nodejs spawn function something like this:
nodeProcess = spawn('node',params, {cwd: '../../node/', detached: true });
For example, this file name is test.js, so just move to the folder which contains it. In my case, it is test folder like this:
cd root/test/
then from run your test runner in my case its mocha so it will be like this:
mocha test.js
I have wasted my more than one day to figure it out. Enjoy!!
solution in my case
var spawn = require('child_process').spawn;
const isWindows = /^win/.test(process.platform);
spawn(isWindows ? 'twitter-proxy.cmd' : 'twitter-proxy');
spawn(isWindows ? 'http-server.cmd' : 'http-server');
I ran into this problem on Windows, where calling exec and spawn with the exact same command (omitting arguments) worked fine for exec (so I knew my command was on $PATH), but spawn would give ENOENT. Turned out that I just needed to append .exe to the command I was using:
import { exec, spawn } from 'child_process';
// This works fine
exec('p4 changes -s submitted');
// This gives the ENOENT error
spawn('p4');
// But this resolves it
spawn('p4.exe');
// Even works with the arguments now
spawn('p4.exe', ['changes', '-s', 'submitted']);
I had this appear while building gulp-jekyll in Powershell on Windows 11.
nodejs 10 LTS, gulp v3.9.1, ruby 3.1, bundler 2.4.5, jekyll 4.2.2
This line of code here is the cause of the ENOENT issue I had with spawn and bundle.
return cp.spawn('bundle', [
'exec',
'jekyll',
'build',
'--source=app', '--destination=build/development', '--config=_config.yml', '--profile'
], { stdio: 'inherit' })
.on('close', done);
Two errors returned, and troubleshooting should start here. ๐Ÿค“๐Ÿง
events.js:174
throw er; // Unhandled 'error' event
^
Error: spawn bundle ENOENT
The cp.spawn is not handling an error Event, so handling that with a simple console.log() will expose the real error with debug information:
return cp.spawn('bundle', [
'exec',
'jekyll',
'build',
'--source=app', '--destination=build/development', '--config=_config.yml', '--profile'
], { stdio: 'inherit' })
.on('error', (e) => console.log(e))
.on('close', done);
This now provides a lot more information to debug with.
{ Error: spawn bundle ENOENT
errno: 'ENOENT',
code: 'ENOENT',
syscall: 'spawn bundle',
path: 'bundle',
spawnargs:
[ 'exec',
'jekyll',
'build',
'--source=app',
'--destination=build/development',
'--config=_config.yml',
'--profile' ] }
The next step to debug would be using the nodejs 10 LTS documentation for child_process.spawn(command[, args][, options]). As already described above, adding the { shell: true } to the options of spawn is a working solution. This is what solved my problem as well. ๐Ÿ˜Œ
{ stdio: 'inherit', shell: true }
This solution is merely a band-aid and could be refactored to handle all environments, but that is out of scope for how to troubleshoot & debug the spawn ENOENT error on nodejs.
I was getting this error when trying to debug a node.js program from within VS Code editor on a Debian Linux system. I noticed the same thing worked OK on Windows. The solutions previously given here weren't much help because I hadn't written any "spawn" commands. The offending code was presumably written by Microsoft and hidden under the hood of the VS Code program.
Next I noticed that node.js is called node on Windows but on Debian (and presumably on Debian-based systems such as Ubuntu) it's called nodejs. So I created an alias - from a root terminal, I ran
ln -s /usr/bin/nodejs /usr/local/bin/node
and this solved the problem. The same or a similar procedure will presumably work in other cases where your node.js is called nodejs but you're running a program which expects it to be called node, or vice-versa.
If you're on Windows Node.js does some funny business when handling quotes that may result in you issuing a command that you know works from the console, but does not when run in Node. For example the following should work:
spawn('ping', ['"8.8.8.8"'], {});
but fails. There's a fantastically undocumented option windowsVerbatimArguments for handling quotes/similar that seems to do the trick, just be sure to add the following to your opts object:
const opts = {
windowsVerbatimArguments: true
};
and your command should be back in business.
spawn('ping', ['"8.8.8.8"'], { windowsVerbatimArguments: true });
Although it may be an environment path or another issue for some people, I had just installed the Latex Workshop extension for Visual Studio Code on Windows 10 and saw this error when attempting to build/preview the PDF. Running VS Code as Administrator solved the problem for me.
In my case removing node, delete all AppData/Roaming/npm and AppData/Roaming/npm-cache and installing node once again solve the issue.
Recently I also faced similar issue.
Starting the development server...
events.js:174
throw er; // Unhandled 'error' event
^
Error: spawn null ENOENT
at Process.ChildProcess._handle.onexit (internal/child_process.js:240:19)
at onErrorNT (internal/child_process.js:415:16)
at process._tickCallback (internal/process/next_tick.js:63:19)
Emitted 'error' event at:
at Process.ChildProcess._handle.onexit (internal/child_process.js:246:12)
at onErrorNT (internal/child_process.js:415:16)
at process._tickCallback (internal/process/next_tick.js:63:19)
error Command failed with exit code 1.
It was due to having a wrong configuration in .env file for BROWSER. I had BROWSER=null, but it has to be BROWSER=none. Changing that configuration resolved my issue.
Tried all nothing worked , my system has different issue .
The working solution for me is
run command :
npm config set script-shell "C:\Program Files\git\bin\bash.exe"
I got the same error for windows 8.The issue is because of an environment variable of your system path is missing . Add "C:\Windows\System32\" value to your system PATH variable.
Local development on Emulator
Make sure to have the package installed locally. By changing the spawn command with exec i got a more detailed error and found out I didn't install the package. Simply run, to check if the package is present:
brew install imagemagick
Source
There might be a case that you have two package-lock.json files in your project directory (in/out of the main folder), simply delete the one which would have been created accidentally. Delete the build folder and run the server again.

NodeJS child_process.execFile() always return Unknown system errno 193

Simply, i can't use the child_process.execFile(). It always contain error in callback.
child.js
console.log('I\'m child');
main.js
var cp = require('child_process');
cp.execFile('./child.js', function (err, stdout,stderr) {
console.log('Err: ',err);
console.log('STDerr: ',stderr);
});
The error object in the callback is
{ [Error: spawn Unknown system errno 193]
code: 'Unknown system errno 193',
errno: 'Unknown system errno 193',
syscall: 'spawn' }
The problem is that child.js is not a valid executable program. If you are on Linux or Mac you can fix that by writing this at the very top of child.js:
#!/usr/bin/env node
You will then need to say chmod +x child.js to make the file executable. The line is called a "shebang line" and it tells the system what interpreter to use to run the rest of the file. You'll need to have node in your $PATH for it to work.
If you don't like that, or are not using a Unix-like system, you can do this:
cp.execFile('/some/path/to/node', ['./child.js'])
The first argument must be the full path to your node interpreter program (perhaps node.exe on Windows, I don't know if that matters).
Finally, none of this really makes that much sense if you don't really need to launch a second node interpreter process. You can try including one file in the other--some ideas for that are here: How do I include a JavaScript file in another JavaScript file?

Node.js error. Cannot understand

I am getting this error while running a simple node program:
/home/ubuntu/parent.js:4
throw error;
^
Error: Command failed: /bin/sh: 1: node: not found
at ChildProcess.exithandler (child_process.js:637:15)
at ChildProcess.EventEmitter.emit (events.js:98:17)
at maybeClose (child_process.js:735:16)
at Socket.<anonymous> (child_process.js:948:11)
at Socket.EventEmitter.emit (events.js:95:17)
at Pipe.close (net.js:466:12)
parent.js :
var exec = require('child_process').exec;
exec('node child.js',{env: {number: 123}},function(error,stdout,stderr){
if(error){ throw error; } console.log('stdout:\t',stdout);
console.log('stderr:\t',stderr);
});
child.js :
var number = process.env.number;
console.log(typeof(number));
When you pass these options:
{env: {number: 123}}
you're overwriting all of the environment variables, so it doesn't inherit your current ones. This includes the PATH, which is required for it to find node. You'll need to copy the current environment variables in addition to the one you want:
env = {};
for(key in process.env) {
env[key] = process.env[key];
}
env.number = 123;
And then you use this env as the env option:
{env: env}
So, you have multiple node instances you're trying to run. To me, this doesn't look right. You can require('child.js') or build your application better.
If you really want to do this, you need to understand paths. The parent node application is running as a user, and once ran by that user, it doesn't seem to have the path to the original node file. try exec'ing the command export PATH=$PATH:/usr/local/bin where /usr/local/bin/node exists. If node is in /bin, then use that. Find where the node executable is and add that bin directory to the path. This has to be done on the user that node runs as.
In node, you might be able to see what PATH is available by doing
exec('echo $PATH')
each directory it's checking for is separated by colons
It would be preferable to do this outside of node, but to me this whole situation seems like it should be rethought from first concepts.

Is it possible to run PhantomJS from node.js as a command line argument

I was recently going to test out running phantomJS from python as a commandline argument, I haven't got round to it yet but have seen examples. Because PhantomJS is run from the command line this seems to be possible. The result that PhantomJS would spit out would go straight into a variable.
Before I go down that path, making this work in node.js would actually be more useful for me and it got me thinking, can i just use to node to run PhantomJS as a program gets run from the commandline and store the data result that PhantomJS would normally spit out into a variable?
I would rather not use phantomjs-node because it seems to be using too many tricks.
The reason for all of this is to be able to run PhantomJS at the same time as another action the program takes and use the resulting data its recorded for some other stuff.
Simply put, you can run system command line stuff in python, can I do the same in node.js?
Cheers :)
Edit: I understand that node and phantom use different js environments, that's cool because I just want to run phantom as its own process and catch all that output data into a node.js variable (the data will be a array of a pair, string and floating point.) I don't want to 'drive' with phantom, I will craft the loaded javascript files todo what I want. All I want is phantom output. :)
From NPM: https://npmjs.org/package/phantomjs
var path = require('path')
var childProcess = require('child_process')
var phantomjs = require('phantomjs')
var binPath = phantomjs.path
var childArgs = [
path.join(__dirname, 'phantomjs-script.js'),
'some other argument (passed to phantomjs script)'
]
childProcess.execFile(binPath, childArgs, function(err, stdout, stderr) {
// handle results
})
I suppose you can make a simple script for Node.js to run; in that script phantomjs script will be run as a child process. You can see the working example (and links for some documentation) in this answer. I suppose this discussion might be helpful for you as well.
As an alternative to Donald Derek's answer, you can use the spawn function. It will allow you to read the child process's output as soon as it's produced rather than the output being buffered and returned to you all at once.
You can read more about it here.
An example from the documentation.
var spawn = require('child_process').spawn,
ls = spawn('ls', ['-lh', '/usr']);
ls.stdout.on('data', function (data) {
console.log('stdout: ' + data);
});
ls.stderr.on('data', function (data) {
console.log('stderr: ' + data);
});
ls.on('close', function (code) {
console.log('child process exited with code ' + code);
});

Equivalent of Rake's 'sh' for Jake?

I've got some experience with Ruby and Rake, but now I'm working on a Node project and want to learn how to do the same things with Jake.
Ruby has a system function that will shell out to a command and wait for it to exit. Rake extends this by adding an sh function that will additionally throw an error if the child process returned a nonzero exit code (or couldn't be found at all). sh is really handy for Rake tasks that shell out to things like compilers or test frameworks, because it automatically terminates the task as soon as anything fails.
Node doesn't seem to have anything like system or sh -- it looks like the nearest equivalents are child_process.spawn and child_process.exec, but neither of them wires up STDOUT or STDERR, so you can't see any output from the child process unless you do some extra work.
What's the best way to get an sh method for Jake? (Though since this is Node, I'd expect it to be async, rather than blocking until the command returns like Ruby does.) Is there an npm module that has already invented this particular wheel, or does someone have a code sample that does this?
I've already seen sh.js, but it looks awfully heavyweight for this (it tries to build an entire command interpreter in Node), and it doesn't look like it's async (though the docs don't say one way or the other).
I'm looking for something that I could use more or less like this (using Jake's support for async tasks):
file('myprogram', ['in.c'], function() {
// sh(command, args, successCallback)
sh('gcc', ['in.c', '-o', 'myprogram'], function() {
// sh should throw if gcc couldn't be found or returned nonzero.
// So if we got here, we can tell Jake our task completed successfully.
complete();
});
}, true);
Here's some code I've come up with that seems to work well. (But if anyone has a better answer, or knows of an existing npm module that already does this, please add another answer.)
Supports full shell syntax, so you can use | and < and > to pipe and redirect output, you can run Windows batch files, etc.
Displays output (both STDOUT and STDERR) as the child process generates it, so you see incremental output as the command runs.
No limitation on the amount of output the command can generate (unlike a previous exec-based version of this code).
Cross-platform (works on Windows, should work on Mac/Linux as well). I borrowed the platform-specific-shell (if platform === 'win32') technique from npm.
Here's the code:
function sh(command, callback) {
var shell = '/bin/sh', args = ['-c', commandLine], child;
if (process.platform === 'win32') {
shell = 'cmd';
args = ['/c', commandLine];
}
child = child_process.spawn(shell, args);
child.stdout.pipe(process.stdout);
child.stderr.pipe(process.stderr);
child.on('exit', function(code, signal) {
if (signal != null)
throw new Error("Process terminated with signal " + signal);
if (code !== 0)
throw new Error("Process exited with error code " + code);
callback();
});
};

Resources