TypeScript icon, indicating that this package has built-in type declarations

    2.0.1 • Public • Published

    npm version downloads build status greenkeeper badge Language grade: JavaScript


    Run a (JavaScript) program with before and after handlers inside the child process. The command can be either a .js file or a node file.js [...] command line, or a Node shebang script.

    If the wrapped script spawns further sub processes, the wrapping will occur to these as well!

    The invoked program will take over standard I/O and become foreground. When the invoked program exits, the parent exits too.



    The interface for haxec is a module exporting a function run:

    const { run } = require( 'haxec' );
    // run is defined as:
    function run(
      wrapModule: string,
      cmdWithArgs: Array< string >,
      options?: Options
    ): void;
    // where options can contain environment variables in the "env" property:
    interface Options
      env?: { [ key: string ]: string; };
      beforeExit?: ( ) => void | Promise< void >;

    The wrapModule is your module (it will make sense to provide an absolut path to it) which haxec will require(). This module is supposed to export a before function and/or a after function. The module will be injected into the command that is being run, so these functions will be called in that process.

    run returns nothing. At this time, the program shouldn't do much else, as the child will take over terminal I/O and exit the parent when the child exits.

    Environment variables can be added to the child, using the env property in the options object.

    To perform any final/cleanup work right before the child has exited, provide a beforeExit callback. If this returns a promise, it will be awaited before exiting the child (and thereby the parent).


    const path = require( "path" );
    const { run } = require( 'haxec' );
    const wrapModule = path.join( __dirname, "child.js" );
    run( wrapModule, [ "node", "file.js", "arg1" ] );
    // which is same as
    run( wrapModule, [ "file.js", "arg1" ] );
    // or as a shebang script
    run( wrapModule, [ "./script-name.sh", "arg1" ] );


    // main.js
    const { run } = require( 'haxec' );
      path.join( __dirname, "child.js" ),
      [ "node", "some-app.js", "arg1" ],
        env: { foo: "bar" }

    This will run some-app.js with arg1 as argument. It will inject this file into it and call its hooks before and after some-app.js is invoked, inside its process:

    // child.js
    module.exports = {
      before( ) {
        console.log( "Child has pid", process.pid );
        // Inject an environment into this process
        process.env.injected = "yes";
        // When this function returns, the main "some-app.js" will run, and it
        // will have { foo: "bar", injected: "yes" } as environment variables.
      after( code ) {
        console.log( "Child exited with code", code );


    npm i haxec

    DownloadsWeekly Downloads






    Unpacked Size

    9.23 kB

    Total Files


    Last publish


    • grantila