fix: avoid syncronous errors in compile method

closes #556, #548, #547, #533

.circleci/build.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+export NVS_HOME="$HOME/.nvs"
+. "$NVS_HOME/nvs.sh" install && nvs link lts && nvs use default
+
+set -e -x
+
+npm run asset-compile

.circleci/config.yml

@@ -0,0 +1,28 @@
+version: 2
+
+jobs:
+  build:
+    macos:
+      xcode: "9.0"
+    steps:
+    - checkout
+    - restore_cache:
+        keys:
+        - package-{{ checksum "package.json" }}-{{ checksum "package-lock.json" }}
+        - package- # Fallback for the latest package.json cache
+    - run:
+        name: setup
+        command: .circleci/setup.sh
+    - save_cache:
+        key: package-{{ checksum "package.json" }}-{{ checksum "package-lock.json" }} 
+        paths:
+        - node_modules
+    - run:
+        name: build
+        command: .circleci/build.sh
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - build

.circleci/setup.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+
+export NVS_HOME="$HOME/.nvs"
+git clone --depth=1 https://github.com/jasongin/nvs "$NVS_HOME"
+. "$NVS_HOME/nvs.sh" install
+nvs add lts && nvs link lts nvs use default
+node -v
+npm -v
+npm i

.gitignore

@@ -4,6 +4,8 @@ coverage
 node_modules
 *.log
 *.exe
+*.bin
+!winsw.exe
 .idea
 .nexe
 lib

.travis.yml

@@ -1,7 +1,14 @@
-language: node_js
-node_js:
-- '6'
-script: npm run nexe-build
-env:
-  global:
-    secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
+language: node_js
+node_js:
+- '6'
+before_install:
+  - sudo apt-get -qq update
+  - sudo apt-get install -y g++-multilib
+node_js:
+- '8'
+script: npm run asset-compile
+env:
+  global:
+    - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
+notifications:
+  email: false

.vscode/extensions.json

@@ -1,5 +1,3 @@
 {
-    "recommendations": [
-      "esbenp.prettier-vscode"
-    ]
+    "recommendations": [ "eg2.tslint" ]
 }

.vscode/settings.json

@@ -1,8 +1,7 @@
 {
-  "typescript.tsdk": "./node_modules/typescript/lib",
-  "prettier.semi": false,
-  "prettier.singleQuote": true,
-  "prettier.typescriptEnable": ["typescript"],
+  "tslint.enable": true,
+  "tslint.run": "onType",
+  "tslint.autoFixOnSave": true,
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,
@@ -14,5 +13,6 @@
     "lib/**/*": true,
     "**/node_modules": true,
     "**/bower_components": true
-  }
+  },
+  "typescript.tsdk": "node_modules\\typescript\\lib"
 }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2017 Nexe Contributors
+Copyright (c) 2013-2018 Nexe Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,22 +1,23 @@
 <p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>
 
 <p align="center">
-  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/nexe/nexe.svg" alt="Build Status"></a>
+  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/github/nexe/nexe/master.svg" alt="Mac Build Status"></a>
+  <a href="https://travis-ci.org/nexe/nexe/builds"><img src="https://img.shields.io/travis/nexe/nexe/master.svg" alt="Linux Build Status"></a>
+  <a href="https://ci.appveyor.com/project/calebboyd/nexe/history"><img src="https://img.shields.io/appveyor/ci/calebboyd/nexe/master.svg" alt="Windows Build Status"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/dt/nexe.svg" alt="Downloads"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/v/nexe.svg" alt="Version"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/l/nexe.svg" alt="License"></a>
 </p>
 
-<p align="center"><code>npm i nexe@beta -g</code></p>
+<p align="center"><code>npm i nexe -g</code></p>
 <p align="center">Nexe is a command-line utility that compiles your Node.js application into a single executable file.</p>
 
 <p align="center">
-  <img src="https://cloud.githubusercontent.com/assets/5818726/26533446/ce19ee5a-43de-11e7-9540-caf7ebd93370.gif"/>
+  <img src="https://user-images.githubusercontent.com/5818726/30999006-df7e0ae0-a497-11e7-96db-9ce87ae67b34.gif"/>
 </p>
 
 ## Motivation and Features
 
-- Supports production ready builds
 - Self contained applications
 - Ability to run multiple applications with *different* node.js runtimes.
 - Distribute binaries without needing node / npm.
@@ -28,40 +29,41 @@
 
 ## Usage
 
-- Existing application bundle:
+- Application entrypoint:
 
-  `nexe my-app-bundle.js -o my-app`
+  `nexe my-app.js`
 
 - stdin interface
 
-  `rollup -c | nexe --resource ./public/**/* -o my-app.exe`
+  `rollup -c | nexe --resource "./public/**/*" -o my-app.exe`
 
 For more CLI options see: `nexe --help`
 
-## Including Additional Resources
+### Examples
 
-Additional resources can be added to the binary by passing `-r glob/pattern/**/*`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`
+- `nexe server.js -r "public/**/*.html"`
+- `nexe --build`
+- `nexe -t x86-8.0.0`
+
+## Resources
+
+Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`.
 
 ## Compiling Node
 
-By default `nexe` will attempt to download a pre-built executable. However, some users may want to customize the way node is built, either by changing the flags, providing a different icon, or different executable details. To build node, use the `build` option/flag
-
-Nexe also exposes its patching pipeline to the user. This allows the application of simple patching of node sources prior to compilation.
+By default `nexe` will attempt to download a pre-built executable. However, It may be unavailable ([github releases](https://github.com/nexe/nexe/releases))
+or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 2. eg. Systems that have python2 will need to create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486).
 
 ## Node.js API
 
-Using Nexe Programatically
-
 #### Example
 
-
 ```javascript
 const { compile } = require('nexe')
 
 compile({
   input: './my-app.js',
-  output: './my-app.exe',
-  build: true, //builds node
+  build: true, //required to use patches
   patches: [
     async (compiler, next) => {
       await compiler.setFileContentsAsync(
@@ -75,92 +77,118 @@ compile({
   console.log('success')
 })
 ```
+## NexeOptions
 
-### `options`
+### `options: object`
 
- - #### `build: boolean`
-    - Build node from source (required in beta)
  - #### `input: string`
     - Input bundle file path
     - default: stdin or the current directory's main file (package.json)
  - #### `output: string`
     - Output executable file path
     - default: same as `name` with an OS specific extension.
- - #### `target: string`
-    - Dash seperated platform-architecture-version. e.g. `'win32-ia32-6.10.3'`
-    - default: `[process.platform, process.arch, process.version.slice(1)].join('-')`
+ - #### `target: string | object`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-10.13.0'`
+      - each segment is optional, and will be merged with the current environment
+      - Examples: ([full list](https://github.com/nexe/nexe/releases))
+        - `'win32-x86-10.13.0`
+        - `{ platform: 'alpine' }`
+        - `darwin-10.13.0`
+        - `linux-x64`
+        - `macos-10.13.0`
+
+        See [test/target.spec.ts](test/target.spec.ts)
+    - If the [`build`](#build-boolean) flag is set, the platform portion of the target is ignored.
+    - default: `process`
 - #### `bundle: string | boolean`
     - If a string is provided it must be a valid relative module path
     and should provide an export with the following signature:
     ```typescript
-    export function createBundle (
-      filename: string,
-      options: { name: string, minify: any, cwd: string }
-    ): Promise<string>`
+    export function createBundle (options: NexeOptions): Promise<string>
     ```
-    - default: true, uses the internal fuse-box configuration
+    - default: true
  - #### `name: string`
     - Module friendly name of the application
     - default: basename of the input file, or `nexe_${Date.now()}`
  - #### `cwd: string`
     - Directory nexe will operate on as though it is the cwd
     - default: process.cwd()
- - #### `version: string`
-    - The Node version you're building for
-    - default: `process.version.slice(1)`
+ - #### `build: boolean`
+    - Build node from source, passing this flag tells nexe to download and build from source. Subsequently using this flag will cause nexe to use the previously built binary. To rebuild, first add [`--clean`](#clean-boolean)
  - #### `python: string`
     - On Linux this is the path pointing to your python2 executable
     - On Windows this is the directory where `python` can be accessed
     - default: `null`
- - #### `flags: Array<string>`
+ - #### `flags: string[]`
     - Array of node runtime flags to build node with.
     - Example: `['--expose-gc']`
     - default: `[]`
- - #### `configure: Array<string>`
+ - #### `configure: string[]`
     - Array of arguments for the node build configure step
     - Example: `['--with-dtrace', '--dest-cpu=x64']`
     - default: `[]`
- - #### `make: Array<string>`
-    - Array of arguments for the node build make step, on windows this step recieves options for vcBuild.bat
-    - default: `[]` or `['nosign', 'release']` for non windows systems
- - #### `make: Array<string>`
-    - Alias for `make` option
+ - #### `make: string[]`
+    - Array of arguments for the node build make step
+    - default: `[]`
+ - #### `vcBuild: string[]`
+    - Options for windows build
+    - default: `['nosign', 'release']`
  - #### `snapshot: string`
     - path to a file to be used as the warmup snapshot for the build
     - default: `null`
- - #### `resources: Array<string>`
+ - #### `resources: string[]`
     - Array of globs with files to include in the build
     - Example: `['./public/**/*']`
     - default: `[]`
  - #### `temp: string`
     - Path to use for storing nexe's build files
     - Override in the env with `NEXE_TEMP`
-    - default: `./.nexe` in the cwd
+    - default: `~/.nexe`
  - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only).
+    - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
  - #### `rc: object`
     - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example: `{ CompanyName: "ACME Corp" }`
+    - Example (keys may vary depending ont the version. Reference the file linked above):
+      ```javascript
+        {
+          CompanyName: "ACME Corp",
+          PRODUCTVERSION: "17,3,0,0",
+          FILEVERSION: "1,2,3,4"
+          ...
+        }
+      ```
     - default: `{}`
  - #### `clean: boolean`
-    - If included, nexe will remove temporary files for accompanying configuration and exit
+    - If included, nexe will remove temporary files for the accompanying configuration and exit
  - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working)
+    - Enable the original Node CLI (will prevent application cli from working).
+    - Node CLI arguments passed via the [NODE_OPTIONS](https://nodejs.org/api/cli.html#cli_node_options_options) environment
+      variable will still be processed. NODE_OPTIONS support can be disabled with the `--without-node-options` configure flag.
     - default: `false`
+  - #### `fakeArgv: boolean`
+    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`. 
+ - #### `ghToken: string`
+    - Provide a Github Token for accessing nexe releases
+    - This is usually needed in CI environments
+    - default: `process.env.GITHUB_TOKEN`
  - #### `sourceUrl: string`
-    - Provide an alternate url for the node source. Should be a `.tar.gz`
+    - Provide an alternate url for the node source code
+    - Note: temporary files will still be created for this under the specified version
  - #### `loglevel: string`
     - Set the loglevel, info, silent, or verbose
     - default: `'info'`
- - #### `patches: Array<NexePatch>`
+ - #### `patches: NexePatch[]`
     - Userland patches for patching or modifying node source
     - default: `[]`
+ - #### `plugins: NexePatch[]`
+    - Userland plugins for modifying nexe executable behavior
+    - default: `[]`
 
 ### `NexePatch: (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>`
 
-A patch is just a middleware function that takes two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior.
+Patches and Plugins are just a middleware functions that take two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior. Patches also require that [`--build`](#build-boolean) be set, while plugins do not.
 
-For examples, see the built in patches: [src/patches](src/patches)
+For examples, see the built in patches: [src/patches](src/patches).
 
 ### `NexeCompiler`
 
@@ -170,7 +198,9 @@ For examples, see the built in patches: [src/patches](src/patches)
     - Quickly perform a replace in a file within the downloaded Node.js source. The rest arguments are passed along to `String.prototype.replace`
  - `readFileAsync(filename: string): Promise<NexeFile>`
     - Access (or create) a file within the downloaded Node.js source.
- - `files: Array<NexeFile>`
+ - `addResource(filename: string, contents: Buffer): void`
+    - Add a resource to the nexe bundle
+ - `files: NexeFile[]`
     - The cache of the currently read, modified, or created files within the downloaded Node.js source.
 
 #### `NexeFile`
@@ -180,18 +210,31 @@ For examples, see the built in patches: [src/patches](src/patches)
 
 Any modifications made to `NexeFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.
 
-### Native Modules
+## Native Modules
 
-Nexe has a plugin built for use with [fuse-box](http://fuse-box.org) > 2.2.1. This plugin currently supports modules that require `.node` files and those that use the `bindings` module.
-Take a look at the [example](examples/native-build/build.js)
+TODO
 
-- [ ] Implement support `node-pre-gyp#find`.
+- [ ] Implement support for `node-pre-gyp#find`.
+
+## Contributing
+
+Building
+```
+$ git clone git@github.com:nexe/nexe.git
+$ cd nexe
+$ yarn
+```
+
+Testing
+```
+$ npm test
+```
 
 ## Maintainers
 
-[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Christopher Karper](https://avatars.githubusercontent.com/u/653156?s=130)](https://github.com/ckarper) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
----|---|---|---
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |
+[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
+---|---|---|
+[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) |  [Dustin Greif](https://github.com/dgreif) |
 
 ### Former
 

appveyor.yml

@@ -1,21 +1,23 @@
+image:
+  - Visual Studio 2017
+  - Visual Studio 2015
 environment:
   CIRCLE_TOKEN:
     secure: TQKcepXmTzCNt4+tUBtYpwEQkdSPwFr9A8ugtoMhNbKu/SW1WM1EpjEu6kYXxpQ4
   TRAVIS_TOKEN:
-    secure: tR7HXYv3x97q90uvPrjUxKZh7R1+uqKct0HdEcqTbsg=
+    secure: 6ni/E6Rbmv6cFWW7QNLkpQY2fVpT7wr7y12GEtektN0=
   GITHUB_TOKEN:
     secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
-branches:
-  except:
-    - master
 install:
-  - ps: Install-Product node 6
+  - ps: Install-Product node 8
+  - curl -L -o nasm.exe https://www.nasm.us/pub/nasm/releasebuilds/2.13.03/win64/nasm-2.13.03-installer-x64.exe
+  - start /wait nasm.exe /S
+  - ps: $env:path="C:\Program Files\nasm;$($env:path)"
   - npm i
 build: off
 test: off
 build_script:
-  - npm run nexe-build
+  - npm run asset-compile
 artifacts:
-  - path: .nexe\**\node.exe
-cache:
-  - node_modules
+  - path: $(HOMEPATH)\.nexe\**\node.exe
+

circle.yml

@@ -1,3 +0,0 @@
-test:
-  override:
-    - npm run nexe-build

examples/express-app/index.js

@@ -0,0 +1,8 @@
+const express = require('express')
+const path = require('path')
+const app = express()
+app.use('/', express.static(path.join(__dirname, 'public')))
+
+
+app.listen(8888)
+

examples/express-app/package-lock.json

@@ -0,0 +1,373 @@
+{
+  "name": "express-app",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "accepts": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz",
+      "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=",
+      "requires": {
+        "mime-types": "~2.1.18",
+        "negotiator": "0.6.1"
+      }
+    },
+    "array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
+    },
+    "body-parser": {
+      "version": "1.18.2",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz",
+      "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=",
+      "requires": {
+        "bytes": "3.0.0",
+        "content-type": "~1.0.4",
+        "debug": "2.6.9",
+        "depd": "~1.1.1",
+        "http-errors": "~1.6.2",
+        "iconv-lite": "0.4.19",
+        "on-finished": "~2.3.0",
+        "qs": "6.5.1",
+        "raw-body": "2.3.2",
+        "type-is": "~1.6.15"
+      }
+    },
+    "bytes": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz",
+      "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg="
+    },
+    "content-disposition": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz",
+      "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ="
+    },
+    "content-type": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz",
+      "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA=="
+    },
+    "cookie": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz",
+      "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s="
+    },
+    "cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw="
+    },
+    "debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "requires": {
+        "ms": "2.0.0"
+      }
+    },
+    "depd": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
+      "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak="
+    },
+    "destroy": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
+      "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
+    },
+    "ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
+    },
+    "encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k="
+    },
+    "escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
+    },
+    "etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc="
+    },
+    "express": {
+      "version": "4.16.3",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.16.3.tgz",
+      "integrity": "sha1-avilAjUNsyRuzEvs9rWjTSL37VM=",
+      "requires": {
+        "accepts": "~1.3.5",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.18.2",
+        "content-disposition": "0.5.2",
+        "content-type": "~1.0.4",
+        "cookie": "0.3.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "~1.1.2",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.1.1",
+        "fresh": "0.5.2",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "~2.3.0",
+        "parseurl": "~1.3.2",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.3",
+        "qs": "6.5.1",
+        "range-parser": "~1.2.0",
+        "safe-buffer": "5.1.1",
+        "send": "0.16.2",
+        "serve-static": "1.13.2",
+        "setprototypeof": "1.1.0",
+        "statuses": "~1.4.0",
+        "type-is": "~1.6.16",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      }
+    },
+    "finalhandler": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.1.tgz",
+      "integrity": "sha512-Y1GUDo39ez4aHAw7MysnUD5JzYX+WaIj8I57kO3aEPT1fFRL4sr7mjei97FgnwhAyyzRYmQZaTHb2+9uZ1dPtg==",
+      "requires": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.3.0",
+        "parseurl": "~1.3.2",
+        "statuses": "~1.4.0",
+        "unpipe": "~1.0.0"
+      }
+    },
+    "forwarded": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz",
+      "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ="
+    },
+    "fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac="
+    },
+    "http-errors": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz",
+      "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=",
+      "requires": {
+        "depd": "~1.1.2",
+        "inherits": "2.0.3",
+        "setprototypeof": "1.1.0",
+        "statuses": ">= 1.4.0 < 2"
+      }
+    },
+    "iconv-lite": {
+      "version": "0.4.19",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz",
+      "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ=="
+    },
+    "inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+    },
+    "ipaddr.js": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.8.0.tgz",
+      "integrity": "sha1-6qM9bd16zo9/b+DJygRA5wZzix4="
+    },
+    "media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g="
+    },
+    "merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E="
+    },
+    "methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4="
+    },
+    "mime": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz",
+      "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ=="
+    },
+    "mime-db": {
+      "version": "1.35.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.35.0.tgz",
+      "integrity": "sha512-JWT/IcCTsB0Io3AhWUMjRqucrHSPsSf2xKLaRldJVULioggvkJvggZ3VXNNSRkCddE6D+BUI4HEIZIA2OjwIvg=="
+    },
+    "mime-types": {
+      "version": "2.1.19",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.19.tgz",
+      "integrity": "sha512-P1tKYHVSZ6uFo26mtnve4HQFE3koh1UWVkp8YUC+ESBHe945xWSoXuHHiGarDqcEZ+whpCDnlNw5LON0kLo+sw==",
+      "requires": {
+        "mime-db": "~1.35.0"
+      }
+    },
+    "ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "negotiator": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz",
+      "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk="
+    },
+    "on-finished": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
+      "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
+      "requires": {
+        "ee-first": "1.1.1"
+      }
+    },
+    "parseurl": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz",
+      "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M="
+    },
+    "path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
+    },
+    "proxy-addr": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.4.tgz",
+      "integrity": "sha512-5erio2h9jp5CHGwcybmxmVqHmnCBZeewlfJ0pex+UW7Qny7OOZXTtH56TGNyBizkgiOwhJtMKrVzDTeKcySZwA==",
+      "requires": {
+        "forwarded": "~0.1.2",
+        "ipaddr.js": "1.8.0"
+      }
+    },
+    "qs": {
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz",
+      "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A=="
+    },
+    "range-parser": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz",
+      "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4="
+    },
+    "raw-body": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz",
+      "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=",
+      "requires": {
+        "bytes": "3.0.0",
+        "http-errors": "1.6.2",
+        "iconv-lite": "0.4.19",
+        "unpipe": "1.0.0"
+      },
+      "dependencies": {
+        "depd": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz",
+          "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k="
+        },
+        "http-errors": {
+          "version": "1.6.2",
+          "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz",
+          "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=",
+          "requires": {
+            "depd": "1.1.1",
+            "inherits": "2.0.3",
+            "setprototypeof": "1.0.3",
+            "statuses": ">= 1.3.1 < 2"
+          }
+        },
+        "setprototypeof": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz",
+          "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ="
+        }
+      }
+    },
+    "safe-buffer": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz",
+      "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg=="
+    },
+    "send": {
+      "version": "0.16.2",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.16.2.tgz",
+      "integrity": "sha512-E64YFPUssFHEFBvpbbjr44NCLtI1AohxQ8ZSiJjQLskAdKuriYEP6VyGEsRDH8ScozGpkaX1BGvhanqCwkcEZw==",
+      "requires": {
+        "debug": "2.6.9",
+        "depd": "~1.1.2",
+        "destroy": "~1.0.4",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "~1.6.2",
+        "mime": "1.4.1",
+        "ms": "2.0.0",
+        "on-finished": "~2.3.0",
+        "range-parser": "~1.2.0",
+        "statuses": "~1.4.0"
+      }
+    },
+    "serve-static": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.13.2.tgz",
+      "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==",
+      "requires": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.2",
+        "send": "0.16.2"
+      }
+    },
+    "setprototypeof": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz",
+      "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ=="
+    },
+    "statuses": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz",
+      "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew=="
+    },
+    "type-is": {
+      "version": "1.6.16",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz",
+      "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==",
+      "requires": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.18"
+      }
+    },
+    "unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw="
+    },
+    "utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM="
+    },
+    "vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw="
+    }
+  }
+}

examples/express-app/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "express-app",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.16.3"
+  }
+}

examples/express-app/public/index.html

@@ -0,0 +1 @@
+<h1>Hello World!</h1>

examples/native-build/build.js

@@ -1,22 +0,0 @@
-const { FuseBox } = require('fuse-box')
-const { NativeModulePlugin } = require('../../lib/bundling')
-const fuse = FuseBox.init({
-  homeDir: './',
-  cache: false,
-  log: true,
-  debug: true,
-  output: '$name.js',
-  plugins: [
-    new NativeModulePlugin({
-      zmq: {
-        additionalFiles: [
-          '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
-        ]
-      }
-    })
-  ]
-})
-fuse.bundle('app')
-    .target('server')
-    .instructions(`> index.js`)
-fuse.run()

examples/native-build/index.js

@@ -1,19 +0,0 @@
-var zmq = require('zmq')
-var pub = zmq.socket('pub')
-
-pub.bindSync('tcp://127.0.0.1:3000')
-console.log('Publisher bound to port 3000')
-
-setInterval(function(){
-  console.log('sending a multipart message envelope')
-  pub.send(['kitty cats', 'meow!'])
-}, 2500)
-console.log('global', global.require.main)
-var sub = zmq.socket('sub')
-sub.connect('tcp://127.0.0.1:3000')
-sub.subscribe('kitty cats')
-console.log('Subscriber connected to port 3000')
-
-sub.on('message', function(topic, message) {
-  console.log('received a message related to:', topic.toString(), 'containing message:', message.toString())
-})

examples/native-build/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "native-build",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "bundle": "node build",
-    "build-windows": "nexe -i app.js -o app.exe"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "zmq": "^2.15.3"
-  },
-  "devDependencies": {
-    "fuse-box": "^2.2.1-beta.7"
-  }
-}

index.js

@@ -1,10 +1,32 @@
 #!/usr/bin/env node
-const nexe = require('./lib/nexe')
-
-module.exports = nexe
-
+const options = require('./lib/options')
 if (require.main === module) {
-  nexe.compile(nexe.argv).catch((e) => {
-    process.stderr.write(e.stack, () => process.exit(1))
-  })
+  //fast path for help/version
+  const argv = options.argv
+  const eol = require('os').EOL
+  const showHelp = argv.help || argv._.some(x => x === 'help')
+  const showVersion = argv.version || argv._.some(x => x === 'version')
+  if (showHelp || showVersion) {    
+    process.stderr.write(showHelp ? options.help : options.version + eol)
+  } else {
+    const nexe = require('./lib/nexe')
+    nexe.compile(argv).catch((error) => {
+      const NexeError = require('./lib/compiler').NexeError
+      const chalk = require('chalk')
+      const isSilent = Boolean(argv.silent === true || argv.loglevel === 'silent')
+      if (!isSilent) {
+        if (error instanceof NexeError) {
+          process.stderr.write(eol + chalk.red('Error: ') + error.message + eol
+            + eol + 'See nexe -h for usage..' + eol + eol
+          )
+        } else {
+          process.stderr.write(error.stack + eol)
+        }
+      }
+
+      process.exit(1)
+    })
+  }
+} else {
+  module.exports = require('./lib/nexe')
 }

issue_template.md

@@ -1,21 +1,19 @@
-This is a
- - [ ] Bug Report
- - [ ] Feature Request
- - [ ] Other
+<!-- If you need help or think you have found a bug, please help us with your issue by entering the following information (otherwise you can delete this text): -->
 
-<br/>
-If this is a bug report, What are the steps to reproduce?
+**Is this a BUG or a FEATURE REQUEST?:** 
 
-```
-//provide configuration here
-```
+**What happened:**
 
-<br/><br/>
-Please also provide:
+**What you expected to happen:**
+
+**How to reproduce it (as minimally and precisely as possible):**
+
+**Anything else we need to know?:**
+
+**Environment**
 
 - Platform(OS/Version):
 - Host Node Version:
 - Target Node Version:
 - Nexe version:
 - Python Version:
-

package.json

@@ -2,27 +2,29 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "2.0.0-rc.1",
+  "version": "3.0.0-beta.15",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
     "Caleb Boyd <caleb.boyd@hotmail.com>"
   ],
   "scripts": {
-    "nexe-build": "ts-node tasks/build",
-    "prebuild": "rimraf lib && npm run lint",
-    "prepublish": "npm run build",
-    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
-    "build": "tsc --declaration"
+    "asset-compile": "ts-node tasks/asset-compile",
+    "test": "mocha",
+    "lint": "tslint \"{src,plugins,tasks}/**/*.ts\" --fix",
+    "prepare": "npm run lint && npm run build && npm test",
+    "prebuild": "rimraf lib",
+    "build": "tsc --declaration",
+    "postbuild": "ts-node tasks/post-build"
   },
   "repository": {
     "type": "git",
     "url": "git://github.com/nexe/nexe.git"
   },
   "files": [
-    "lib",
-    "source-map-support.js"
+    "lib"
   ],
+  "typings": "lib/nexe.d.ts",
   "main": "index.js",
   "bin": {
     "nexe": "index.js"
@@ -31,33 +33,44 @@
     "node": ">=6"
   },
   "dependencies": {
-    "app-builder": "^5.1.0",
-    "chalk": "^1.1.3",
-    "download": "^6.2.0",
-    "fuse-box": "^2.2.1",
-    "globby": "^6.1.0",
+    "@calebboyd/semaphore": "^1.3.1",
+    "app-builder": "^5.2.0",
+    "caw": "^2.0.1",
+    "chalk": "^2.4.1",
+    "cherow": "1.6.8",
+    "download": "^7.1.0",
+    "globby": "^8.0.1",
+    "got": "^9.5.0",
     "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",
-    "ora": "^1.2.0",
-    "pifi": "1.0.0",
-    "rimraf": "^2.6.1",
-    "uglify-js": "3.0.28"
+    "multistream": "^2.1.1",
+    "ora": "^3.0.0",
+    "pify": "^4.0.1",
+    "resolve-dependencies": "^2.2.1",
+    "rimraf": "^2.6.2"
   },
   "devDependencies": {
-    "@types/bluebird": "^3.5.8",
-    "@types/chalk": "^0.4.31",
-    "@types/execa": "0.7.0",
-    "@types/globby": "^0.6.0",
+    "@types/chai": "^4.1.7",
+    "@types/download": "^6.2.4",
+    "@types/execa": "^0.9.0",
+    "@types/globby": "^8.0.0",
+    "@types/got": "^9.2.2",
     "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^0.3.29",
-    "@types/ora": "^0.3.31",
-    "@types/pify": "0.0.28",
-    "@types/rimraf": "0.0.28",
-    "execa": "0.8.0",
-    "got": "^7.1.0",
-    "mocha": "^3.2.0",
-    "prettier": "^1.6.1",
-    "ts-node": "3.3.0",
-    "typescript": "^2.4.1"
+    "@types/mkdirp": "^0.5.2",
+    "@types/mocha": "^5.2.5",
+    "@types/multistream": "^2.1.1",
+    "@types/ora": "^1.3.4",
+    "@types/pify": "3.0.2",
+    "@types/rimraf": "2.0.2",
+    "@types/semver": "^5.5.0",
+    "chai": "^4.2.0",
+    "execa": "^1.0.0",
+    "mocha": "^5.2.0",
+    "prettier": "^1.15.3",
+    "ts-node": "^7.0.1",
+    "tslint": "^5.12.0",
+    "tslint-config-prettier": "^1.17.0",
+    "tslint-plugin-prettier": "^2.0.1",
+    "typescript": "^3.2.2"
   }
 }

src/bundling/bindings-rewrite.ts

@@ -1,162 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child from 'child_process'
-import { createHash } from 'crypto'
-
-export interface ExtractNodeModuleOptions {
-  [key: string]: { additionalFiles: string[] } | true
-}
-
-function hashName(name: string | Buffer) {
-  return createHash('md5')
-    .update(name)
-    .digest('hex')
-    .toString()
-    .slice(0, 8)
-}
-
-export function embedDotNode(
-  options: ExtractNodeModuleOptions,
-  file: { contents: string; absPath: string }
-) {
-  const contents = fs.readFileSync(file.absPath)
-  const module = Object.keys(options).find(x =>
-    Boolean(~file.absPath.indexOf(path.join('node_modules', x)))
-  )!
-  const bindingName = path.basename(file.absPath)
-  const settings = options[module]
-  const moduleDir = hashName(contents)
-  file.contents = `
-  var fs=require('fs');var path=require('path');var binding='${contents.toString(
-    'base64'
-  )}';function mkdirp(r,t){t=t||null,r=path.resolve(r);try{fs.mkdirSync(r),t=t||r}catch(c){if("ENOENT"===c.code)t=mkdirp(path.dirname(r),t),mkdirp(r,t);else{var i;try{i=fs.statSync(r)}catch(r){throw c}if(!i.isDirectory())throw c}}return t};`
-
-  if (settings === true) {
-    file.contents += `
-      mkdirp('${moduleDir}');
-      var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
-      require('fs').writeFileSync(bindingPath, Buffer.from(binding, 'base64'))
-      process.dlopen(module, bindingPath)
-    `.trim()
-    return
-  }
-
-  let depth = 0
-  settings.additionalFiles.forEach(file => {
-    let ownDepth = 0
-    file.split('/').forEach(x => x === '..' && ownDepth++)
-    depth = ownDepth > depth ? ownDepth : depth
-  })
-  let segments = [moduleDir]
-  while (depth--) {
-    segments.push(hashName(moduleDir + depth))
-  }
-  segments.push(bindingName)
-
-  file.contents += `
-    var cwd = process.cwd()
-    var bindingFileParts = ${JSON.stringify(segments)};
-    var bindingFile = path.join.apply(path, [cwd].concat(bindingFileParts));
-    mkdirp(path.dirname(bindingFile));
-    fs.writeFileSync(bindingFile, Buffer.from(binding, 'base64'));
-    ${settings.additionalFiles.reduce((code, filename, i) => {
-      const contents = fs.readFileSync(path.join(path.dirname(file.absPath), filename))
-      return (code += `
-        var file${i} = '${contents.toString('base64')}';
-        var filePath${i} = path.join(cwd, bindingFileParts[0], '${filename.split('../').join('')}');
-        mkdirp(path.dirname(filePath${i}));
-        fs.writeFileSync(filePath${i}, Buffer.from(file${i}, 'base64'));
-      `)
-    }, '')};
-    process.dlopen(module, bindingFile)
-  `
-}
-
-function findNativeModulePath(filePath: string, bindingsArg: string) {
-  const dirname = path.dirname(filePath)
-  const tempFile = Math.random() * 100 + '.js'
-  const tempFilePath = path.join(dirname, tempFile)
-  fs.writeFileSync(
-    tempFilePath,
-    `
-    var bindings = require('bindings');
-    var Module = require('module');
-    var originalRequire = Module.prototype.require;
-    Module.prototype.require = function(path) {
-      const mod = originalRequire.apply(this, arguments);
-      process.stdout.write(path)
-      return mod
-    };
-    bindings('${bindingsArg}')
-  `
-  )
-  //using exec because it can be done sync
-  const nativeFileName = child.execSync('node ' + tempFile, { cwd: dirname }).toString()
-  fs.unlinkSync(tempFilePath)
-  const relativePath = './' + path.relative(dirname, nativeFileName).replace(/\\/g, '/')
-  return relativePath
-}
-/**
- * Traverse all nodes in a file and evaluate usages of the bindings module
- * handles two common cases
- */
-export class BindingsRewrite {
-  private bindingsIdNodes: any[] = []
-  public nativeModulePaths: string[] = []
-  public rewrite = false
-
-  isRequireBindings(node: any) {
-    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
-  }
-
-  onNode(absolutePath: string, node: any, parent: any) {
-    if (node.type === 'CallExpression') {
-      if (this.isRequireBindings(node) && parent.type === 'VariableDeclarator') {
-        /**
-         * const loadBindings = require('bindings');
-         *   -> const loadBindings = String('');
-         */
-        this.bindingsIdNodes.push(parent.id)
-        node.callee.name = 'String'
-        node.arguments[0].value = ''
-        this.rewrite = true
-        return
-      }
-
-      if (this.isRequireBindings(node) && parent.type === 'CallExpression') {
-        /**
-         *const bindings = require('bindings')('native-module')....
-         *  -> const bindings = require('./path/to/native/module.node').....
-         */
-        const bindingsArgNode = parent.arguments[0]
-        if (bindingsArgNode.type === 'Literal') {
-          parent.callee = { type: 'Identifier', name: 'require' }
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-
-      const bindingsInvocationIdx = this.bindingsIdNodes.findIndex(x => node.callee.name === x.name)
-
-      if (this.bindingsIdNodes[bindingsInvocationIdx]) {
-        /**
-         * const bindings = loadBindings('native-module')
-         *   -> const bindings = require('./path/to/native/module.node')
-         */
-        const bindingsIdNode = this.bindingsIdNodes[bindingsInvocationIdx]
-        const bindingsArgNode = node.arguments[0]
-        this.bindingsIdNodes.splice(bindingsInvocationIdx, 1)
-
-        if (bindingsArgNode.type === 'Literal') {
-          node.callee.name = 'require'
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-    }
-  }
-}

src/bundling/fuse-native-module-plugin.ts

@@ -1,70 +0,0 @@
-import { BindingsRewrite, embedDotNode, ExtractNodeModuleOptions } from './bindings-rewrite'
-
-export interface FuseBoxFile {
-  info: { absPath: string }
-  absPath: string
-  contents: string
-  analysis: {
-    dependencies: string[]
-    requiresRegeneration: boolean
-  }
-  loadContents(): void
-  makeAnalysis(
-    parsingOptions?: any,
-    traversalPlugin?: {
-      plugins: Array<{
-        onNode(file: FuseBoxFile, node: any, parent: any): void
-        onEnd(file: FuseBoxFile): void
-      }>
-    }
-  ): void
-}
-
-export default function(options: ExtractNodeModuleOptions) {
-  return new NativeModulePlugin(options)
-}
-
-export class NativeModulePlugin {
-  public test: RegExp
-  public limit2Project = false
-  private modules: (keyof ExtractNodeModuleOptions)[]
-
-  constructor(public options: ExtractNodeModuleOptions) {
-    this.options = options
-    this.test = new RegExp(`node_modules\/(${Object.keys(options).join('|')}).*\.js|\.node$`)
-  }
-
-  init(context: any) {
-    context.allowExtension('.node')
-  }
-
-  transform(file: FuseBoxFile) {
-    file.loadContents()
-
-    if (file.absPath.endsWith('.node')) {
-      embedDotNode(this.options, file)
-      return
-    }
-
-    const bindingsRewrite = new BindingsRewrite()
-    file.makeAnalysis(null, {
-      plugins: [
-        {
-          onNode(file, node, parent) {
-            bindingsRewrite.onNode(file.absPath, node, parent)
-          },
-          onEnd(file) {
-            if (bindingsRewrite.rewrite) {
-              const index = file.analysis.dependencies.indexOf('bindings')
-              if (~index) {
-                file.analysis.dependencies.splice(index, 1)
-              }
-              file.analysis.dependencies.push(...bindingsRewrite.nativeModulePaths)
-              file.analysis.requiresRegeneration = true
-            }
-          }
-        }
-      ]
-    })
-  }
-}

src/bundling/fuse.ts

@@ -1,57 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
-import { readFileAsync } from '../util'
-//import NativeModulePlugin from './fuse-native-module-plugin'
-
-function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
-  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
-  if (options.minify) {
-    plugins.push(
-      QuantumPlugin({
-        target: 'server',
-        uglify: true,
-        bakeApiIntoBundle: options.name
-      })
-    )
-  }
-  const fuse = FuseBox.init({
-    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
-    homeDir: options.cwd,
-    sourceMaps: false,
-    writeBundles: false,
-    output: '$name.js',
-    target: 'server',
-    plugins
-  })
-  fuse.bundle(options.name).instructions(`> ${filename}`)
-  return fuse.run().then(x => {
-    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
-    return output
-  })
-}
-
-export default async function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    compiler.input = await readFileAsync(compiler.options.input, 'utf-8')
-    return next()
-  }
-
-  if (compiler.options.empty || !compiler.options.input) {
-    compiler.input = ''
-    return next()
-  }
-
-  let producer = createBundle
-  if (typeof compiler.options.bundle === 'string') {
-    producer = require(compiler.options.bundle).createBundle
-  }
-
-  compiler.input = await producer(compiler.options.input, {
-    cwd: compiler.options.cwd,
-    name: compiler.options.name,
-    minify: compiler.options.compress
-  })
-  return next()
-}

src/bundling/index.ts

@@ -1 +0,0 @@
-export * from './fuse-native-module-plugin'

src/compiler.ts

@@ -1,99 +1,195 @@
-import { dirname, normalize, join } from 'path'
+import { delimiter, dirname, normalize, join } from 'path'
 import { Buffer } from 'buffer'
-import { createHash } from 'crypto'
-import { createReadStream } from 'fs'
-import { Readable } from 'stream'
+import { createReadStream, ReadStream } from 'fs'
 import { spawn } from 'child_process'
-import { Logger } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
-import { NexeOptions, nexeVersion } from './options'
+import { Logger, LogStep } from './logger'
+import {
+  readFileAsync,
+  writeFileAsync,
+  pathExistsAsync,
+  statAsync,
+  dequote,
+  isWindows,
+  bound,
+  semverGt
+} from './util'
+import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
-import { getLatestGitRelease, storeAsset } from './releases'
+import download = require('download')
+import { getLatestGitRelease } from './releases'
+import { IncomingMessage } from 'http'
+import combineStreams = require('multistream')
+import { Bundle, toStream } from './fs/bundle'
 
 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
 const configure = isWindows ? 'configure' : './configure'
 
+type StringReplacer = (match: string) => string
+
 export interface NexeFile {
   filename: string
   absPath: string
   contents: string
 }
 
-interface NexeHeader {
-  resources: { [key: string]: number[] }
-  version: string
+export { NexeOptions }
+
+export class NexeError extends Error {
+  constructor(m: string) {
+    super(m)
+    Object.setPrototypeOf(this, NexeError.prototype)
+  }
 }
 
 export class NexeCompiler {
+  /**
+   * Epoch of when compilation started
+   */
   private start = Date.now()
-  private env = { ...process.env }
-  private compileStep: { modify: Function; log: Function }
+  private compileStep: LogStep | undefined
   public log = new Logger(this.options.loglevel)
-  public src = join(this.options.temp, this.options.version)
+  /**
+   * Copy of process.env
+   */
+  public env = { ...process.env }
+  /**
+   * Virtual FileSystem
+   */
+  public bundle: Bundle
+  /**
+   * Root directory for the source of the current build
+   */
+  public src: string
+  /**
+   * In memory files that are being manipulated by the compiler
+   */
   public files: NexeFile[] = []
-  public input: string
-  public bundledInput?: string
-  public output: string | null
-
-  public resources: { bundle: string; index: { [key: string]: number[] } } = {
-    index: {},
-    bundle: ''
-  }
-  public readFileAsync: (file: string) => Promise<NexeFile>
-  public writeFileAsync: (file: string, contents: Buffer | string) => Promise<void>
-  public replaceInFileAsync: (file: string, replacer: any, replaceValue: string) => Promise<void>
-  public setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>
-
-  private nodeSrcBinPath = isWindows
-    ? join(this.src, 'Release', 'node.exe')
-    : join(this.src, 'out', 'Release', 'node')
+  /**
+   * Standalone pieces of code run before the application entrypoint
+   */
+  public shims: string[] = []
+  /**
+   * The last shim (defaults to "require('module').runMain()")
+   */
+  public startup: string = ''
+  /**
+   * The main entrypoint filename for your application - eg. node mainFile.js
+   */
+  public entrypoint: string | undefined
+  /**
+   * Not used
+   */
+  public targets: NexeTarget[]
+  /**
+   * Current target of the compiler
+   */
+  public target: NexeTarget
+  /**
+   * Output filename (-o myapp.exe)
+   */
+  public output = this.options.output
+  /**
+   * Flag to indicate whether or notstdin was used for input
+   */
+  public stdinUsed = false
+  /**
+   * Path to the configure script
+   */
+  public configureScript: string
+  /**
+   * The file path of node binary
+   */
+  public nodeSrcBinPath: string
 
   constructor(public options: NexeOptions) {
     const { python } = (this.options = options)
-    this.log.step('nexe ' + nexeVersion, 'info')
-    if (python) {
-      if (isWindows) {
-        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
-      } else {
-        this.env.PYTHON = python
-      }
-    }
-
-    this.readFileAsync = async (file: string) => {
-      let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
-      if (!cachedFile) {
-        const absPath = join(this.src, file)
-        cachedFile = {
-          absPath,
-          filename: file,
-          contents: await readFileAsync(absPath, 'utf-8').catch(x => {
-            if (x.code === 'ENOENT') return ''
-            throw x
-          })
-        }
-        this.files.push(cachedFile)
-      }
-      return cachedFile
-    }
-    this.writeFileAsync = (file, contents) => writeFileAsync(join(this.src, file), contents)
-    this.replaceInFileAsync = async (file, replace: string | RegExp, value: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = entry.contents.replace(replace, value)
-    }
-    this.setFileContentsAsync = async (file: string, contents: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = contents
+    this.targets = options.targets as NexeTarget[]
+    this.target = this.targets[0]
+    this.src = join(this.options.temp, this.target.version)
+    this.configureScript = configure + (semverGt(this.target.version, '10.10.0') ? '.py' : '')
+    this.nodeSrcBinPath = isWindows
+      ? join(this.src, 'Release', 'node.exe')
+      : join(this.src, 'out', 'Release', 'node')
+    this.log.step('nexe ' + version, 'info')
+    this.bundle = new Bundle(options)
+    if (isWindows) {
+      const originalPath = process.env.PATH
+      delete process.env.PATH
+      this.env = { ...process.env }
+      this.env.PATH = python
+        ? (this.env.PATH = dequote(normalize(python)) + delimiter + originalPath)
+        : originalPath
+      process.env.PATH = originalPath
+    } else {
+      this.env = { ...process.env }
+      python && (this.env.PYTHON = python)
     }
   }
 
-  quit() {
+  @bound
+  addResource(file: string, content?: Buffer | string) {
+    return this.bundle.addResource(file, content)
+  }
+
+  get binaryConfiguration() {
+    return { resources: this.bundle.index }
+  }
+
+  get resourceSize() {
+    return this.bundle.blobSize
+  }
+
+  @bound
+  async readFileAsync(file: string) {
+    this.assertBuild()
+    let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+    if (!cachedFile) {
+      const absPath = join(this.src, file)
+      cachedFile = {
+        absPath,
+        filename: file,
+        contents: await readFileAsync(absPath, 'utf-8').catch(x => {
+          if (x.code === 'ENOENT') return ''
+          throw x
+        })
+      }
+      this.files.push(cachedFile)
+    }
+    return cachedFile
+  }
+
+  @bound
+  writeFileAsync(file: string, contents: string | Buffer) {
+    this.assertBuild()
+    return writeFileAsync(join(this.src, file), contents)
+  }
+
+  @bound
+  async replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = entry.contents.replace(replace, value as any)
+  }
+
+  @bound
+  async setFileContentsAsync(file: string, contents: string) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = contents
+  }
+
+  quit(error?: any) {
     const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
+    this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green')
     return this.log.flush()
   }
 
-  private _getNodeExecutableLocation(target?: NexeTarget) {
+  assertBuild() {
+    if (!this.options.build) {
+      throw new NexeError('This feature is only available with `--build`')
+    }
+  }
+
+  public getNodeExecutableLocation(target?: NexeTarget) {
     if (target) {
       return join(this.options.temp, target.toString())
     }
@@ -101,110 +197,147 @@ export class NexeCompiler {
   }
 
   private _runBuildCommandAsync(command: string, args: string[]) {
+    if (this.log.verbose) {
+      this.compileStep!.pause()
+    }
     return new Promise((resolve, reject) => {
       spawn(command, args, {
         cwd: this.src,
         env: this.env,
-        stdio: 'ignore'
+        stdio: this.log.verbose ? 'inherit' : 'ignore'
       })
-        .once('error', reject)
-        .once('close', resolve)
+        .once('error', (e: Error) => {
+          if (this.log.verbose) {
+            this.compileStep!.resume()
+          }
+          reject(e)
+        })
+        .once('close', (code: number) => {
+          if (this.log.verbose) {
+            this.compileStep!.resume()
+          }
+          if (code != 0) {
+            const error = `${command} ${args.join(' ')} exited with code: ${code}`
+            reject(new NexeError(error))
+          }
+          resolve()
+        })
     })
   }
 
   private _configureAsync() {
     return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
-      configure,
+      this.configureScript,
       ...this.options.configure
     ])
   }
 
-  private async _buildAsync() {
-    this.compileStep.log(
-      `Configuring node build${this.options.configure.length
-        ? ': ' + this.options.configure
-        : '...'}`
+  public async build(): Promise<ReadStream> {
+    this.compileStep!.log(
+      `Configuring node build${
+        this.options.configure.length ? ': ' + this.options.configure : '...'
+      }`
     )
     await this._configureAsync()
     const buildOptions = this.options.make
-    this.compileStep.log(
+    this.compileStep!.log(
       `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
     )
     await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this._getNodeExecutableLocation())
+    return createReadStream(this.getNodeExecutableLocation())
   }
 
   private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    const githubRelease = await getLatestGitRelease()
+    let downloadOptions = this.options.downloadOptions
+
+    if (this.options.ghToken) {
+      downloadOptions = Object.assign({}, downloadOptions)
+      downloadOptions.headers = Object.assign({}, downloadOptions.headers, {
+        Authorization: 'token ' + this.options.ghToken
+      })
+    }
+
+    const githubRelease = await getLatestGitRelease(downloadOptions)
     const assetName = target.toString()
     const asset = githubRelease.assets.find(x => x.name === assetName)
 
     if (!asset) {
-      throw new Error(`${assetName} not available, create one using --build`)
+      throw new NexeError(`${assetName} not available, create it using the --build flag`)
     }
-    const filename = this._getNodeExecutableLocation(target)
-    await storeAsset(asset, dirname(filename))
+    const filename = this.getNodeExecutableLocation(target)
+
+    await download(asset.browser_download_url, dirname(filename), this.options.downloadOptions).on(
+      'response',
+      (res: IncomingMessage) => {
+        const total = +res.headers['content-length']!
+        let current = 0
+        res.on('data', data => {
+          current += data.length
+          this.compileStep!.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
+        })
+      }
+    )
     return createReadStream(filename)
   }
 
-  private _generateHeader() {
-    const version =
-      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
-        return (a += (this.options as any)[c]
-          .slice()
-          .sort()
-          .join())
-      }, '') + this.options.enableNodeCli
-    const header = {
-      resources: this.resources.index,
-      version: createHash('md5')
-        .update(version)
-        .digest('hex')
-    }
-    const serializedHeader = this._serializeHeader(header)
-    return header
-  }
+  private async _shouldCompileBinaryAsync(
+    binary: NodeJS.ReadableStream | null,
+    location: string | undefined
+  ) {
+    //TODO combine make/configure/vcBuild/and modified times of included files
+    const { snapshot, build } = this.options
 
-  private _serializeHeader(header: NexeHeader) {
-    return `process.__nexe=${JSON.stringify(header)};`
+    if (!binary) {
+      return true
+    }
+
+    if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
+      const snapshotLastModified = (await statAsync(snapshot)).mtimeMs
+      const binaryLastModified = (await statAsync(location)).mtimeMs
+      // if build was requested and there's a snapshot to embed in the binary,
+      // we need to rebuild if the snapshot was just modified.
+      return snapshotLastModified > binaryLastModified
+    }
+
+    return false
   }
 
   async compileAsync(target: NexeTarget) {
     const step = (this.compileStep = this.log.step('Compiling result'))
     const build = this.options.build
-    const location = this._getNodeExecutableLocation(target)
+    const location = this.getNodeExecutableLocation(build ? undefined : target)
     let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
-    const header = this._generateHeader()
-
-    if (target && !build) {
+    if (!build && !binary) {
+      step.modify('Fetching prebuilt binary')
       binary = await this._fetchPrebuiltBinaryAsync(target)
     }
-
-    if (!binary) {
-      binary = await this._buildAsync()
+    if (await this._shouldCompileBinaryAsync(binary, location)) {
+      binary = await this.build()
       step.log('Node binary compiled')
     }
-    return this._assembleDeliverable(header, binary)
+    return this._assembleDeliverable(binary!)
   }
 
-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
-    if (this.options.empty) {
+  code() {
+    return [this.shims.join(''), this.startup].join(';')
+  }
+
+  private _assembleDeliverable(binary: NodeJS.ReadableStream) {
+    if (!this.options.mangle) {
       return binary
     }
-    const artifact = new Readable({ read() {} })
-    binary.on('data', (chunk: Buffer) => {
-      artifact.push(chunk)
-    })
-    binary.on('close', () => {
-      const content = this._serializeHeader(header) + this.input
-      artifact.push(content)
-      artifact.push(this.resources.bundle)
-      const lengths = Buffer.from(Array(16))
-      lengths.writeDoubleLE(Buffer.byteLength(content), 0)
-      lengths.writeDoubleLE(Buffer.byteLength(this.resources.bundle), 8)
-      artifact.push(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
-      artifact.push(null)
-    })
-    return artifact
+
+    const startup = this.code(),
+      codeSize = Buffer.byteLength(startup)
+
+    const lengths = Buffer.from(Array(16))
+    lengths.writeDoubleLE(codeSize, 0)
+    lengths.writeDoubleLE(this.bundle.blobSize, 8)
+    return combineStreams([
+      binary,
+      toStream(startup),
+      this.bundle.toStream(),
+      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
+    ])
   }
 }

src/fs/README.md

@@ -0,0 +1,40 @@
+# nexe-fs
+
+### Getting Started:
+
+This module contains a set of patches used to create (and use) the Nexe Virtual FileSystem
+
+In order for NVFS to work with node's `require` method. A custom build of node must be used. If using the `nexe` cli this will be handled automatically
+
+The customization should be applied as early as possbile when node is starting up. 
+
+i.e. The contents of `nexe-fs/bootstrap` should be put [here](https://github.com/nodejs/node/blob/0827c80920311fa9d1e6989c8a73aaaeca962eb7/lib/internal/bootstrap/node.js#L27-L28).
+
+### Creating a NVFS:
+
+To create a virtual file system use the `Bundle` Object, in your build process:
+
+```javascript
+const { Bundle } = require('nexe-fs')
+
+const bundle = new Bundle()
+await bundle.addResource(absoluteFileName)
+
+bundle.toStream().pipe(fs.createWriteStream('./myFsBlob'))
+```
+
+In the entrypoint of your application, the fs patch needs to be applied (executed as early as possible)
+For example, In the build process, the application's entrypoint could be prepended with the following:
+
+```javascript
+const codeToPrependToEntrypoint = fs.readFileSync(require.resolve('nexe-fs/patch'), 'utf-8') + `
+shimFs({
+  blobPath: 'location/of/myFsBlob',
+  resources: ${JSON.stringify(bundle)},
+  layout: {
+    resourceStart: 0 // the offset within the blob that is referenced by the bundle index
+  }
+})`
+```
+
+Since a custom node build is being used. A great place for this code would be the node source file: `_third_party_main.js`

src/fs/bootstrap.js

@@ -0,0 +1,20 @@
+if (true) {
+  const __nexe_patches = (process.nexe = { patches: {} }).patches
+  const slice = [].slice
+  const __nexe_noop_patch = function (original) {
+    const args = slice.call(arguments, 1)
+    return original.apply(this, args)
+  }
+  const __nexe_patch = function (obj, method, patch) {
+    const original = obj[method]
+    if (!original) return
+    __nexe_patches[method] = patch
+    obj[method] = function() {
+      const args = [original].concat(slice.call(arguments))
+      return __nexe_patches[method].apply(this, args)
+    }
+  }
+  __nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)
+}

src/fs/bundle.ts

@@ -0,0 +1,70 @@
+import { stat as getStat, Stats, createReadStream } from 'fs'
+import { relative } from 'path'
+import { Readable } from 'stream'
+import combineStreams = require('multistream')
+
+const stat = (file: string): Promise<Stats> => {
+  return new Promise((resolve, reject) => {
+    getStat(file, (err, stats) => (err ? reject(err) : resolve(stats)))
+  })
+}
+
+function makeRelative(cwd: string, path: string) {
+  return './' + relative(cwd, path)
+}
+
+export function toStream(content: Buffer | string) {
+  const readable = new Readable({ read() {} })
+  readable.push(content)
+  readable.push(null)
+  return readable
+}
+
+export type File = { absPath: string; contents: string; deps: FileMap }
+export type FileMap = { [absPath: string]: File | null }
+
+export interface BundleOptions {
+  entries: string[]
+  cwd: string
+  expand: boolean
+  loadContent: boolean
+  files: FileMap
+}
+
+export class Bundle {
+  constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
+    this.cwd = cwd
+  }
+  cwd: string
+  blobSize: number = 0
+  index: { [relativeFilePath: string]: [number, number] } = {}
+  streams: (Readable | (() => Readable))[] = []
+
+  async addResource(absoluteFileName: string, content?: Buffer | string) {
+    let length = 0
+    if (content !== undefined) {
+      length = Buffer.byteLength(content)
+    } else {
+      const stats = await stat(absoluteFileName)
+      length = stats.size
+    }
+
+    const start = this.blobSize
+
+    this.blobSize += length
+    this.index[makeRelative(this.cwd, absoluteFileName)] = [start, length]
+    this.streams.push(() => (content ? toStream(content) : createReadStream(absoluteFileName)))
+  }
+
+  concat() {
+    throw new Error('Not Implemented')
+  }
+
+  toStream() {
+    return combineStreams(this.streams)
+  }
+
+  toJSON() {
+    return this.index
+  }
+}

src/fs/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "nexe-fs",
+  "version": "1.0.1",
+  "description": "Virtual File System used by nexe",
+  "main": "bundle.js",
+  "files": [
+    "*.d.ts",
+    "*.js"
+  ],
+  "author": "Caleb Boyd",
+  "dependencies": {
+    "multistream": "^2.1.1"
+  },
+  "license": "MIT"
+}

src/fs/patch.ts

@@ -0,0 +1,340 @@
+import { Stats } from 'fs'
+
+export interface NexeBinary {
+  blobPath: string
+  resources: { [key: string]: number[] }
+  layout: {
+    stat: Stats
+    resourceStart: number
+    contentSize?: number
+    contentStart?: number
+    resourceSize?: number
+  }
+}
+
+let originalFsMethods: any = null
+let nexeBinary: NexeBinary | null = null
+
+function restoreFs(fs: any = require('fs')): NexeBinary | false {
+  if (!nexeBinary) {
+    return false
+  }
+  const source = nexeBinary
+  Object.assign(fs, originalFsMethods)
+  nexeBinary = originalFsMethods = null
+  return source
+}
+
+function shimFs(binary: NexeBinary, fs: any = require('fs')) {
+  if (originalFsMethods !== null) {
+    return
+  }
+  originalFsMethods = Object.assign({}, fs)
+  nexeBinary = binary
+  const { blobPath, resources: manifest } = binary
+  const { resourceStart, stat } = binary.layout
+  const directories: { [key: string]: { [key: string]: boolean } } = {},
+    notAFile = '!@#$%^&*',
+    isWin = process.platform.startsWith('win'),
+    isString = (x: any): x is string => typeof x === 'string' || x instanceof String,
+    isNotFile = () => false,
+    isNotDirectory = isNotFile,
+    isFile = () => true,
+    noop = () => {},
+    isDirectory = isFile,
+    path = require('path')
+
+  let log = (text: string) => true
+  if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
+    log = (text: string) => process.stderr.write('[nexe] - ' + text + '\n')
+  }
+
+  const getKey = function getKey(filepath: string | Buffer | null): string {
+    if (Buffer.isBuffer(filepath)) {
+      filepath = filepath.toString()
+    }
+    if (!isString(filepath)) {
+      return notAFile
+    }
+    let key = path.resolve(filepath)
+
+    if (isWin && key.substr(1, 2) === ':\\') {
+      key = key[0].toUpperCase() + key.substr(1)
+    }
+    return key
+  }
+
+  const statTime = function() {
+    return {
+      dev: 0,
+      ino: 0,
+      nlink: 0,
+      rdev: 0,
+      uid: 123,
+      gid: 500,
+      blksize: 4096,
+      blocks: 0,
+      atime: new Date(stat.atime),
+      atimeMs: stat.atime.getTime(),
+      mtime: new Date(stat.mtime),
+      mtimeMs: stat.mtime.getTime(),
+      ctime: new Date(stat.ctime),
+      ctimMs: stat.ctime.getTime(),
+      birthtime: new Date(stat.birthtime),
+      birthtimeMs: stat.birthtime.getTime()
+    }
+  }
+
+  const createStat = function(directoryExtensions: any, fileExtensions?: any) {
+    if (!fileExtensions) {
+      return Object.assign({}, binary.layout.stat, directoryExtensions, { size: 0 }, statTime())
+    }
+    const size = directoryExtensions[1]
+    return Object.assign({}, binary.layout.stat, fileExtensions, { size }, statTime())
+  }
+
+  const ownStat = function(filepath: any) {
+    setupManifest()
+    const key = getKey(filepath)
+    if (directories[key]) {
+      return createStat({ isDirectory, isFile: isNotFile })
+    }
+    if (manifest[key]) {
+      return createStat(manifest[key], { isFile, isDirectory: isNotDirectory })
+    }
+  }
+
+  function makeLong(filepath: string) {
+    return (path as any)._makeLong && (path as any)._makeLong(filepath)
+  }
+
+  function fileOpts(options: any) {
+    return !options ? {} : isString(options) ? { encoding: options } : options
+  }
+
+  let setupManifest = () => {
+    Object.keys(manifest).forEach(filepath => {
+      const entry = manifest[filepath]
+      const absolutePath = getKey(filepath)
+      const longPath = makeLong(absolutePath)
+      const normalizedPath = path.normalize(filepath)
+
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = entry
+      }
+      if (longPath && !manifest[longPath]) {
+        manifest[longPath] = entry
+      }
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[filepath]
+      }
+
+      let currentDir = path.dirname(absolutePath)
+      let prevDir = absolutePath
+
+      while (currentDir !== prevDir) {
+        directories[currentDir] = directories[currentDir] || {}
+        directories[currentDir][path.basename(prevDir)] = true
+        const longDir = makeLong(currentDir)
+        if (longDir && !directories[longDir]) {
+          directories[longDir] = directories[currentDir]
+        }
+        prevDir = currentDir
+        currentDir = path.dirname(currentDir)
+      }
+    })
+    ;(manifest[notAFile] as any) = false
+    ;(directories[notAFile] as any) = false
+    setupManifest = noop
+  }
+
+  //naive patches intended to work for most use cases
+  const nfs: any = {
+    existsSync: function existsSync(filepath: string) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key] || directories[key]) {
+        return true
+      }
+      return originalFsMethods.existsSync.apply(fs, arguments)
+    },
+    realpath: function realpath(filepath: any, options: any, cb: any): void {
+      setupManifest()
+      const key = getKey(filepath)
+      if (isString(filepath) && (manifest[filepath] || manifest[key])) {
+        return process.nextTick(() => cb(null, filepath))
+      }
+      return originalFsMethods.realpath.call(fs, filepath, options, cb)
+    },
+    realpathSync: function realpathSync(filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key]) {
+        return filepath
+      }
+      return originalFsMethods.realpathSync.call(fs, filepath, options)
+    },
+    readdir: function readdir(filepath: string | Buffer, options: any, callback: any) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        if ('function' === typeof options) {
+          callback = options
+          options = { encoding: 'utf8' }
+        }
+        process.nextTick(() => callback(null, Object.keys(dir)))
+      } else {
+        return originalFsMethods.readdir.apply(fs, arguments)
+      }
+    },
+    readdirSync: function readdirSync(filepath: string | Buffer, options: any) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        return Object.keys(dir)
+      }
+      return originalFsMethods.readdirSync.apply(fs, arguments)
+    },
+
+    readFile: function readFile(filepath: any, options: any, callback: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFile.apply(fs, arguments)
+      }
+      const [offset, length] = entry
+      const resourceOffset = resourceStart + offset
+      const encoding = fileOpts(options).encoding
+      callback = typeof options === 'function' ? options : callback
+
+      fs.open(blobPath, 'r', function(err: Error, fd: number) {
+        if (err) return callback(err, null)
+        fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function(
+          error: Error,
+          bytesRead: number,
+          result: Buffer
+        ) {
+          if (error) {
+            return fs.close(fd, function() {
+              callback(error, null)
+            })
+          }
+          fs.close(fd, function(err: Error) {
+            if (err) {
+              return callback(err, result)
+            }
+            callback(err, encoding ? result.toString(encoding) : result)
+          })
+        })
+      })
+    },
+    createReadStream: function createReadStream(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.createReadStream.apply(fs, arguments)
+      }
+      const [offset, length] = entry
+      const resourceOffset = resourceStart + offset
+      const opts = fileOpts(options)
+
+      return fs.createReadStream(
+        blobPath,
+        Object.assign({}, opts, {
+          start: resourceOffset,
+          end: resourceOffset + length - 1
+        })
+      )
+    },
+    readFileSync: function readFileSync(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFileSync.apply(fs, arguments)
+      }
+      const [offset, length] = entry
+      const resourceOffset = resourceStart + offset
+      const encoding = fileOpts(options).encoding
+      const fd = fs.openSync(process.execPath, 'r')
+      const result = Buffer.alloc(length)
+      fs.readSync(fd, result, 0, length, resourceOffset)
+      fs.closeSync(fd)
+      return encoding ? result.toString(encoding) : result
+    },
+    statSync: function statSync(filepath: string | Buffer) {
+      const stat = ownStat(filepath)
+      if (stat) {
+        return stat
+      }
+      return originalFsMethods.statSync.apply(fs, arguments)
+    },
+    stat: function stat(filepath: string | Buffer, callback: any) {
+      const stat = ownStat(filepath)
+      if (stat) {
+        process.nextTick(() => {
+          callback(null, stat)
+        })
+      } else {
+        return originalFsMethods.stat.apply(fs, arguments)
+      }
+    }
+  }
+
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function(filepath: string, cb: Function) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      process.nextTick(() => cb(exists))
+    }
+  }
+
+  const patches = (process as any).nexe.patches || {}
+  delete (process as any).nexe
+  patches.internalModuleReadFile = function(this: any, original: any, ...args: any[]) {
+    const [filepath] = args
+    setupManifest()
+    if (manifest[filepath]) {
+      log('read     (hit)              ' + filepath)
+      return nfs.readFileSync(filepath, 'utf-8')
+    }
+    log('read          (miss)       ' + filepath)
+    return original.call(this, ...args)
+  }
+  patches.internalModuleReadJSON = patches.internalModuleReadFile
+  patches.internalModuleStat = function(this: any, original: any, ...args: any[]) {
+    setupManifest()
+    const [filepath] = args
+    if (manifest[filepath]) {
+      log('stat     (hit)              ' + filepath + '   ' + 0)
+      return 0
+    }
+    if (directories[filepath]) {
+      log('stat dir (hit)              ' + filepath + '   ' + 1)
+      return 1
+    }
+    const res = original.call(this, ...args)
+    if (res === 0) {
+      log('stat          (miss)        ' + filepath + '   ' + res)
+    } else if (res === 1) {
+      log('stat dir      (miss)        ' + filepath + '   ' + res)
+    } else {
+      log('stat                 (fail) ' + filepath + '   ' + res)
+    }
+    return res
+  }
+
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function(filepath: string, cb: Function) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      if (!exists) {
+        return originalFsMethods.exists(filepath, cb)
+      }
+      process.nextTick(() => cb(exists))
+    }
+  }
+  Object.assign(fs, nfs)
+  return true
+}
+
+export { shimFs, restoreFs }

src/logger.ts

@@ -6,10 +6,12 @@ const frameLength = 120
 export interface LogStep {
   modify(text: string, color?: string): void
   log(text: string, color?: string): void
+  pause(): void
+  resume(): void
 }
 
 export class Logger {
-  private verbose: boolean
+  public verbose: boolean
   private silent: boolean
   private ora: any
   private modify: Function
@@ -48,7 +50,7 @@ export class Logger {
 
   step(text: string, method: string = 'succeed'): LogStep {
     if (this.silent) {
-      return { modify() {}, log() {} }
+      return { modify() {}, log() {}, pause() {}, resume() {} }
     }
     if (!this.ora.id) {
       this.ora.start().text = text
@@ -62,7 +64,9 @@ export class Logger {
 
     return {
       modify: this.modify,
-      log: this.verbose ? this.write : this.modify
+      log: this.verbose ? this.write : this.modify,
+      pause: () => this.ora.stopAndPersist(),
+      resume: () => this.ora.start()
     } as LogStep
   }
 }

src/nexe.ts

@@ -1,49 +1,48 @@
-import { compose, PromiseConfig, Middleware } from 'app-builder'
+import { EOL } from 'os'
+import { compose } from 'app-builder'
+import { NexeCompiler, NexeError } from './compiler'
+import { normalizeOptions, NexeOptions, NexePatch } from './options'
 import resource from './steps/resource'
-import { NexeCompiler } from './compiler'
-import {
-  argv,
-  nexeVersion as version,
-  normalizeOptionsAsync,
-  NexeOptions,
-  NexePatch
-} from './options'
+import clean from './steps/clean'
 import cli from './steps/cli'
-import bundle from './bundling/fuse'
+import bundle from './steps/bundle'
 import download from './steps/download'
+import shim from './steps/shim'
 import artifacts from './steps/artifacts'
 import patches from './patches'
-import { rimrafAsync } from './util'
 
 async function compile(
   compilerOptions?: Partial<NexeOptions>,
   callback?: (err: Error | null) => void
 ) {
-  const options = await normalizeOptionsAsync(compilerOptions)
-  const compiler = new NexeCompiler(options)
-  const build = compiler.options.build
+  let error = null,
+    options: NexeOptions | null = null,
+    compiler: NexeCompiler | null = null
 
-  if (options.clean) {
-    const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting directory and contents at: ${compiler.src}`)
-    await rimrafAsync(compiler.src)
-    step.log(`Deleted directory and contents at: ${compiler.src}`)
-    return compiler.quit()
+  try {
+    options = normalizeOptions(compilerOptions)
+    compiler = new NexeCompiler(options)
+    await compose(
+      clean,
+      resource,
+      cli,
+      bundle,
+      shim,
+      options.build ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])] : [],
+      options.plugins as NexePatch[]
+    )(compiler)
+  } catch (e) {
+    error = e
   }
 
-  const buildSteps = build
-    ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])]
-    : []
-  const nexe = compose(resource, bundle, cli, buildSteps)
-  return callback
-    ? void nexe(compiler).then(
-        () => callback && callback(null),
-        (e: Error) => {
-          if (callback) callback(e)
-          else throw e
-        }
-      )
-    : nexe(compiler)
+  if (error) {
+    compiler && compiler.quit(error)
+    if (callback) return callback(error)
+    return Promise.reject(error)
+  }
+
+  if (callback) callback(null)
 }
 
-export { argv, compile, version }
+export { compile, NexeCompiler }
+export { argv, version, NexeOptions, help } from './options'

src/options.ts

@@ -1,11 +1,15 @@
 import * as parseArgv from 'minimist'
-import { NexeCompiler } from './compiler'
-import { isWindows } from './util'
-import { basename, extname, join, isAbsolute, relative } from 'path'
+import { NexeCompiler, NexeError } from './compiler'
+import { isWindows, STDIN_FLAG } from './util'
+import { basename, extname, join, isAbsolute, resolve } from 'path'
 import { getTarget, NexeTarget } from './target'
-import { EOL } from 'os'
+import { EOL, homedir } from 'os'
+import chalk from 'chalk'
+import { resolveFileNameSync } from 'resolve-dependencies'
+const caw = require('caw')
+const c = process.platform === 'win32' ? chalk.constructor({ enabled: false }) : chalk
 
-export const nexeVersion = '2.0.0-rc.1'
+export const version = '{{replace:0}}'
 
 export interface NexePatch {
   (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -18,7 +22,6 @@ export interface NexeOptions {
   targets: (string | NexeTarget)[]
   name: string
   cwd: string
-  version: string
   flags: string[]
   configure: string[]
   vcBuild: string[]
@@ -30,14 +33,25 @@ export interface NexeOptions {
   enableNodeCli: boolean
   bundle: boolean | string
   patches: (string | NexePatch)[]
+  plugins: (string | NexePatch)[]
+  native: any
+  /**
+   * @deprecated
+   * Use mangle: false instead
+   */
   empty: boolean
+  mangle: boolean
+  ghToken: string
   sourceUrl?: string
+  enableStdIn?: boolean
   python?: string
   loglevel: 'info' | 'silent' | 'verbose'
   silent?: boolean
+  fakeArgv?: boolean
   verbose?: boolean
   info?: boolean
   ico?: string
+  debugBundle?: boolean
   warmup?: string
   compress?: boolean
   clean?: boolean
@@ -47,12 +61,7 @@ export interface NexeOptions {
   downloadOptions: any
 }
 
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-
 const defaults = {
-  version: process.version.slice(1),
   flags: [],
   cwd: process.cwd(),
   configure: [],
@@ -63,56 +72,68 @@ const defaults = {
   compress: false,
   build: false,
   bundle: true,
-  patches: []
+  patches: [],
+  plugins: []
 }
 const alias = {
   i: 'input',
   o: 'output',
-  t: 'target',
-  n: 'name',
   v: 'version',
+  t: 'target',
+  b: 'build',
+  n: 'name',
   r: 'resource',
   a: 'resource',
   p: 'python',
   f: 'flag',
   c: 'configure',
   m: 'make',
-  s: 'snapshot',
   h: 'help',
-  l: 'loglevel'
+  l: 'loglevel',
+  'fake-argv': 'fakeArgv',
+  'gh-token': 'ghToken'
 }
-const argv = parseArgv(process.argv, { alias, default: defaults })
-const help =
-  `
-nexe --help              CLI OPTIONS
+const argv = parseArgv(process.argv, { alias, default: { ...defaults } })
+let help = `
+${c.bold('nexe <entry-file> [options]')}
 
-  -b   --build                              -- build from source
-  -i   --input      =index.js               -- application entry point
-  -o   --output     =my-app.exe             -- path to output file
-  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
-  -n   --name       =my-app                 -- main app module name
-  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
-  -p   --python     =/path/to/python2       -- python executable
-  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
-  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure step
-  -m   --make       ="--loglevel"           -- *pass arguments to the make/build step
-  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
-  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
-       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
-       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
-       --no-bundle                          -- set when input is already bundled
-       --cwd                                -- set the current working directory for the command
-       --ico                                -- file name for alternate icon file (windows)
-       --rc-*                               -- populate rc file options (windows)
-       --clean                              -- force download of sources
-       --enableNodeCli                      -- enable node cli enforcement (blocks app cli)
-       --sourceUrl                          -- pass an alternate source (node.tar.gz) url
-       --silent                             -- disable logging
-       --verbose                            -- set logging to verbose
+   ${c.underline.bold('Options:')}
 
-       -* variable key name                 * option can be used more than once`.trim() + EOL
+  -i   --input                      -- application entry point
+  -o   --output                     -- path to output file
+  -t   --target                     -- node version description
+  -n   --name                       -- main app module name
+  -r   --resource                   -- *embed files (glob) within the binary
+       --plugin                     -- extend nexe runtime behavior
 
-function flattenFilter(...args: any[]): string[] {
+   ${c.underline.bold('Building from source:')}
+
+  -b   --build                      -- build from source
+  -p   --python                     -- python2 (as python) executable path
+  -f   --flag                       -- *v8 flags to include during compilation
+  -c   --configure                  -- *arguments to the configure step
+  -m   --make                       -- *arguments to the make/build step
+       --no-mangle                  -- used when generating base binaries, or when pathing _third_party_main manually.
+       --snapshot                   -- path to a warmup snapshot
+       --ico                        -- file name for alternate icon file (windows)
+       --rc-*                       -- populate rc file options (windows)
+       --sourceUrl                  -- pass an alternate source (node.tar.gz) url
+       --enableNodeCli              -- enable node cli enforcement (blocks app cli)
+
+   ${c.underline.bold('Other options:')}
+
+       --bundle                     -- custom bundling module with 'createBundle' export
+       --temp                       -- temp file storage default '~/.nexe'
+       --cwd                        -- set the current working directory for the command
+       --fake-argv                  -- fake argv[1] with entry file
+       --clean                      -- force download of sources
+       --silent                     -- disable logging
+       --verbose                    -- set logging to verbose
+
+       -* variable key name         * option can be used more than once`.trim()
+help = EOL + help + EOL
+
+function flatten(...args: any[]): string[] {
   return ([] as string[]).concat(...args).filter(x => x)
 }
 
@@ -125,22 +146,15 @@ function flattenFilter(...args: any[]): string[] {
 function extractCliMap(match: RegExp, options: any) {
   return Object.keys(options)
     .filter(x => match.test(x))
-    .reduce((map: { [key: string]: string }, option: keyof NexeOptions) => {
-      const key = option.split('-')[1]
-      map[key] = options[option]
-      delete options[option]
-      return map
-    }, {})
-}
-
-function tryResolveMainFileName(cwd: string) {
-  let filename
-  try {
-    const file = require.resolve(cwd)
-    filename = basename(file).replace(extname(file), '')
-  } catch (_) {}
-
-  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
+    .reduce(
+      (map: any, option: any) => {
+        const key = option.split('-')[1]
+        map[key] = options[option]
+        delete options[option]
+        return map
+      },
+      {} as any
+    )
 }
 
 function extractLogLevel(options: NexeOptions) {
@@ -150,84 +164,135 @@ function extractLogLevel(options: NexeOptions) {
   return 'info'
 }
 
+function isName(name: string) {
+  return name && name !== 'index'
+}
+
 function extractName(options: NexeOptions) {
   let name = options.name
-  if (!name && typeof options.input === 'string') {
+  //try and use the input filename as the output filename if its not index
+  if (!isName(name) && typeof options.input === 'string') {
     name = basename(options.input).replace(extname(options.input), '')
   }
-  name = name || tryResolveMainFileName(options.cwd)
+  //try and use the directory as the filename
+  if (!isName(name) && basename(options.cwd)) {
+    name = basename(options.cwd)
+  }
+
   return name.replace(/\.exe$/, '')
 }
 
-function isEntryFile(filename: string) {
-  return filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
+function padRelative(input: string) {
+  let prefix = ''
+  if (!input.startsWith('.')) {
+    prefix = './'
+  }
+  return prefix + input
 }
 
-function findInput(input: string, cwd: string) {
-  const maybeInput = argv._.slice().pop() || ''
-  if (input) {
+function isEntryFile(filename?: string): filename is string {
+  return Boolean(filename && !isAbsolute(filename))
+}
+
+export function resolveEntry(
+  input: string,
+  cwd: string,
+  maybeEntry: string | undefined,
+  bundle: boolean | string
+) {
+  let result = null
+  if (input === '-' || maybeEntry === '-') {
+    return STDIN_FLAG
+  }
+  if (input && isAbsolute(input)) {
     return input
   }
-  if (isEntryFile(maybeInput)) {
-    return maybeInput
+  if (input) {
+    const inputPath = padRelative(input)
+    result = resolveFileNameSync(cwd, inputPath)
   }
-  try {
-    const main = require.resolve(cwd)
-    return './' + relative(cwd, main)
-  } catch (e) {
-    void e
+  if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
+    const inputPath = padRelative(maybeEntry)
+    result = resolveFileNameSync(cwd, inputPath)
   }
-
-  return ''
+  if (!process.stdin.isTTY && (!result || !result.absPath) && bundle === defaults.bundle) {
+    return STDIN_FLAG
+  }
+  if (!result || !result.absPath) {
+    result = resolveFileNameSync(cwd, '.')
+  }
+  if (!result.absPath) {
+    throw new NexeError(`Entry file "${input || ''}" not found!`)
+  }
+  return result.absPath
 }
 
-function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions | never> {
-  if (argv.help || argv._.some((x: string) => x === 'version') || argv.version === true) {
-    return new Promise(() => {
-      process.stderr.write(argv.help ? help : nexeVersion + EOL, () => process.exit(0))
-    })
-  }
+function isCli(options?: Partial<NexeOptions>) {
+  return argv === options
+}
+
+function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
   const options = Object.assign({}, defaults, input) as NexeOptions
   const opts = options as any
-
-  options.temp = process.env.NEXE_TEMP || join(options.cwd, '.nexe')
+  const cwd = (options.cwd = resolve(options.cwd))
+  options.temp = options.temp
+    ? resolve(cwd, options.temp)
+    : process.env.NEXE_TEMP || join(homedir(), '.nexe')
+  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined
+  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle)
+  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG
   options.name = extractName(options)
-  options.input = findInput(options.input, options.cwd)
   options.loglevel = extractLogLevel(options)
-  options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets)
-  options.make = flattenFilter(options.vcBuild, options.make)
-  options.configure = flattenFilter(options.configure)
-  options.resources = flattenFilter(opts.resource, options.resources)
+  options.flags = flatten(opts.flag, options.flags)
+  options.targets = flatten(opts.target, options.targets).map(getTarget)
+  if (!options.targets.length) {
+    options.targets.push(getTarget())
+  }
+  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || ''
+  options.make = flatten(isWindows ? options.vcBuild : options.make)
+  options.configure = flatten(options.configure)
+  options.resources = flatten(opts.resource, options.resources)
+
+  options.downloadOptions = options.downloadOptions || {}
+  options.downloadOptions.headers = options.downloadOptions.headers || {}
+  options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)'
+  options.downloadOptions.agent = process.env.HTTPS_PROXY
+    ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
+    : options.downloadOptions.agent || require('https').globalAgent
+  options.downloadOptions.rejectUnauthorized = process.env.HTTPS_PROXY ? false : true
+
   options.rc = options.rc || extractCliMap(/^rc-.*/, options)
+  options.output =
+    (options.targets[0] as NexeTarget).platform === 'windows'
+      ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
+      : `${options.output || options.name}`
+  options.output = resolve(cwd, options.output)
 
-  options.targets = options.targets.map(getTarget)
-
-  if (options.build && options.targets.length) {
+  if (options.build) {
     const { arch } = options.targets[0] as NexeTarget
     if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat([arch])))
+      options.make = Array.from(new Set(options.make.concat(arch)))
     } else {
       options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
     }
   }
 
-  if (!options.targets.length) {
-    options.targets = [getTarget(options.version)]
-  }
-
-  options.patches = options.patches.map(x => {
+  const requireDefault = (x: string) => {
     if (typeof x === 'string') {
       return require(x).default
     }
     return x
-  })
+  }
+
+  options.mangle = 'mangle' in opts ? opts.mangle : !opts.empty
+  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
+  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
 
   Object.keys(alias)
     .filter(k => k !== 'rc')
     .forEach(x => delete opts[x])
 
-  return Promise.resolve(options)
+  return options
 }
 
-export { argv, normalizeOptionsAsync }
+export { argv, normalizeOptions, help }

src/patches/boot-nexe.ts

@@ -0,0 +1,54 @@
+const fs = require('fs'),
+  fd = fs.openSync(process.execPath, 'r'),
+  stat = fs.statSync(process.execPath),
+  footer = Buffer.alloc(32, 0)
+
+fs.readSync(fd, footer, 0, 32, stat.size - 32)
+
+if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
+  throw 'Invalid Nexe binary'
+}
+
+const contentSize = footer.readDoubleLE(16),
+  resourceSize = footer.readDoubleLE(24),
+  contentStart = stat.size - 32 - resourceSize - contentSize,
+  resourceStart = contentStart + contentSize
+
+Object.defineProperty(
+  process,
+  '__nexe',
+  (function() {
+    let nexeHeader: any = null
+    return {
+      get: function() {
+        return nexeHeader
+      },
+      set: function(value: any) {
+        if (nexeHeader) {
+          throw new Error('This property is readonly')
+        }
+        nexeHeader = Object.assign({}, value, {
+          blobPath: process.execPath,
+          layout: {
+            stat,
+            contentSize,
+            contentStart,
+            resourceSize,
+            resourceStart
+          }
+        })
+        Object.freeze(nexeHeader)
+      },
+      enumerable: false,
+      configurable: false
+    }
+  })()
+)
+
+const contentBuffer = Buffer.from(Array(contentSize)),
+  Module = require('module')
+
+fs.readSync(fd, contentBuffer, 0, contentSize, contentStart)
+fs.closeSync(fd)
+
+new Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath)

src/patches/build-fixes.ts

@@ -1,7 +1,7 @@
 import { NexeCompiler } from '../compiler'
 
 export default async function buildFixes(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!compiler.options.version.startsWith('8.2')) {
+  if (!compiler.target.version.startsWith('8.2')) {
     return next()
   }
 

src/patches/disable-node-cli.ts

@@ -1,12 +1,38 @@
 import { NexeCompiler } from '../compiler'
+import { semverGt } from '../util'
 
 export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
   if (compiler.options.enableNodeCli) {
     return next()
   }
 
-  const nodeccMarker = "argv[index][0] == '-'"
+  if (semverGt(compiler.target.version, '10.9')) {
+    await compiler.replaceInFileAsync('src/node.cc', /(?<!void )ProcessArgv\(/g, '//ProcessArgv(')
+  } else if (semverGt(compiler.target.version, '9.999')) {
+    await compiler.replaceInFileAsync(
+      'src/node.cc',
+      'int i = 1; i < v8_argc; i++',
+      'int i = v8_argc; i < v8_argc; i++'
+    )
+    let matches = 0
+    await compiler.replaceInFileAsync('src/node.cc', /v8_argc > 1/g, match => {
+      if (matches++) {
+        return 'false'
+      }
+      return match
+    })
+  } else {
+    const nodeccMarker = 'argv[index][0] =='
+
+    await compiler.replaceInFileAsync(
+      'src/node.cc',
+      `${nodeccMarker} '-'`,
+      // allow NODE_OPTIONS, introduced in 8.0
+      semverGt(compiler.target.version, '7.99')
+        ? `(${nodeccMarker} (is_env ? '-' : ']'))`
+        : `(${nodeccMarker} ']')`
+    )
+  }
 
-  await compiler.replaceInFileAsync('src/node.cc', nodeccMarker, nodeccMarker.replace('-', ']'))
   return next()
 }

src/patches/index.ts

@@ -1,12 +1,12 @@
 import gyp from './gyp'
-import nexePatches from './third-party-main'
+import bootNexe from './third-party-main'
 import buildFixes from './build-fixes'
 import cli from './disable-node-cli'
 import flags from './flags'
 import ico from './ico'
 import rc from './node-rc'
-import { NexeCompiler } from '../compiler'
+import snapshot from './snapshot'
 
-const patches = [gyp, nexePatches, buildFixes, cli, flags, ico, rc]
+const patches = [gyp, bootNexe, buildFixes, cli, flags, ico, rc, snapshot]
 
 export default patches

src/patches/node-rc.ts

@@ -12,7 +12,15 @@ export default async function nodeRc(compiler: NexeCompiler, next: () => Promise
     let value = options[key]
     const isVar = /^[A-Z_]+$/.test(value)
     value = isVar ? value : `"${value}"`
-    file.contents.replace(new RegExp(`VALUE "${key}",*`), `VALUE "${key}", ${value}`)
+    file.contents = file.contents.replace(
+      new RegExp(`VALUE "${key}",.*`),
+      `VALUE "${key}", ${value}`
+    )
+  })
+  ;['PRODUCTVERSION', 'FILEVERSION'].forEach(x => {
+    if (options[x]) {
+      file.contents = file.contents.replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
+    }
   })
 
   return next()

src/patches/snapshot.ts

@@ -1,18 +1,20 @@
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'
 
-export default async function snapshot(compiler: NexeCompiler, next: () => Promise<void>) {
-  const snapshotFile = compiler.options.snapshot
-  const warmupScript = compiler.options.warmup
+export default async function(compiler: NexeCompiler, next: () => Promise<void>) {
+  const { snapshot, warmup, cwd } = compiler.options
 
-  if (!snapshotFile) {
+  if (!snapshot) {
     return next()
   }
 
   await compiler.replaceInFileAsync(
-    'configure',
+    compiler.configureScript,
     'def configure_v8(o):',
-    `def configure_v8(o):\n  o['variables']['embed_script'] = '${snapshotFile}'\n  o['variables']['warmup_script'] = '${warmupScript ||
-      snapshotFile}'`
+    `def configure_v8(o):\n  o['variables']['embed_script'] = r'${resolve(
+      cwd,
+      snapshot
+    )}'\n  o['variables']['warmup_script'] = r'${resolve(cwd, warmup || snapshot)}'`
   )
 
   return next()

src/patches/third-party-main.ts

@@ -1,126 +1,64 @@
 import { NexeCompiler } from '../compiler'
-import { readFileSync } from 'fs'
-import { join } from 'path'
+import { parse } from 'cherow'
+import { semverGt } from '../util'
+
+function walkSome(node: any, visit: Function) {
+  if (!node || typeof node.type !== 'string' || node._visited) {
+    return false
+  }
+  visit(node)
+  node._visited = true
+  for (let childNode in node) {
+    const child = node[childNode]
+    if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) {
+        if (walkSome(child[i], visit)) {
+          return true
+        }
+      }
+    } else if (walkSome(child, visit)) {
+      return true
+    }
+  }
+  return false
+}
 
 export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
+  let bootFile = 'lib/internal/bootstrap_node.js'
+  const { version } = compiler.target
+
+  if (version.startsWith('4.')) {
+    bootFile = 'src/node.js'
+  } else if (semverGt(version, '9.10.1')) {
+    bootFile = 'lib/internal/bootstrap/node.js'
+  }
+
+  const file = await compiler.readFileAsync(bootFile),
+    ast = parse(file.contents, {
+      loc: true,
+      tolerant: true,
+      next: true,
+      globalReturn: true,
+      node: true,
+      skipShebang: true
+    }),
+    location = { start: { line: 0 } }
+
+  walkSome(ast, (node: any) => {
+    if (!location.start.line && node.type === 'BlockStatement') {
+      //Find the first block statement and mark the location
+      Object.assign(location, node.loc)
+      return true
+    }
+  })
+
+  const fileLines = file.contents.split('\n')
+  fileLines.splice(location.start.line, 0, '{{replace:lib/fs/bootstrap.js}}' + '\n')
+  file.contents = fileLines.join('\n')
+
   await compiler.setFileContentsAsync(
     'lib/_third_party_main.js',
-    `
-const fs = require('fs')
-const path = require('path')
-const Buffer = require('buffer').Buffer
-const isString = x => typeof x === 'string' || x instanceof String
-
-const fd = fs.openSync(process.execPath, 'r')
-const size = fs.statSync(process.execPath).size
-const footer = Buffer.from(Array(32))
-fs.readSync(fd, footer, 0, 32, size - 32)
-
-if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
-  throw 'Invalid Nexe binary'
-}
-
-const contentSize = footer.readDoubleLE(16)
-const resourceSize = footer.readDoubleLE(24)
-const contentStart = size - 32 - resourceSize - contentSize
-const resourceStart = contentStart + contentSize
-
-Object.defineProperty(process, '__nexe', (function () {
-  let nexeHeader = null
-  return {
-    get: function () {
-      return nexeHeader
-    },
-    set: function (value) {
-      if (nexeHeader) {
-        throw new Error('__nexe cannot be reconfigured')
-      }
-      nexeHeader = value
-      Object.freeze(nexeHeader)
-    },
-    enumerable: false,
-    configurable: false
-  }
-})());
-
-if (resourceSize) {
-  const originalReadFile = fs.readFile
-  const originalReadFileSync = fs.readFileSync
-  let setupManifest = () => {
-    const manifest = process.__nexe && process.__nexe.resources
-    if (!manifest) {
-      return
-    }
-    Object.keys(manifest).forEach((key) => {
-      const absolutePath = path.resolve(key)
-      if (!manifest[absolutePath]) {
-        manifest[absolutePath] = manifest[key]
-      }
-      const normalizedPath = path.normalize(key)
-      if (!manifest[normalizedPath]) {
-        manifest[normalizedPath] = manifest[key]
-      }
-    })
-    normalizeManifest = () => {}
-  };
-  fs.readFile = function readFile (file, options, callback) {
-    setupManifest()
-    const manifest = process.__nexe
-    const entry = manifest && manifest.resources[file]
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFile.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    callback = typeof options === 'function' ? options : callback
-
-    fs.open(process.execPath, 'r', function (err, fd) {
-      if (err) return callback(err, null)
-      fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function (error, bytesRead, buffer) {
-        if (error) {
-          return fs.close(fd, function () {
-            callback(error, null)
-          })
-        }
-        fs.close(fd, function (err) {
-          if (err) {
-            return callback(err, buffer)
-          }
-          const result = Buffer.from(buffer.toString(), 'base64')
-          callback(err, encoding ? result.toString(encoding) : result)
-        })
-      })
-    })
-  }
-
-  fs.readFileSync = function readFileSync (file, options) {
-    setupManifest()
-    const manifest = process.__nexe
-    const entry = manifest && manifest.resources[file]
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFileSync.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    const fd = fs.openSync(process.execPath, 'r')
-    const result = Buffer.alloc(length)
-    fs.readSync(fd, result, 0, length, resourceOffset)
-    fs.closeSync(fd)
-    const contents = Buffer.from(result.toString(), 'base64')
-    return encoding ? contents.toString(encoding) : contents
-  }
-}
-
-const contentBuffer = Buffer.from(Array(contentSize));
-fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
-fs.closeSync(fd);
-const Module = require('module');
-process.mainModule = new Module(process.execPath, null);
-process.mainModule.loaded = true;
-process.mainModule._compile(contentBuffer.toString(), process.execPath);
-`.trim()
+    '{{replace:lib/patches/boot-nexe.js}}'
   )
   return next()
 }

src/releases.ts

@@ -1,16 +1,8 @@
 import got = require('got')
-import download = require('download')
-import {
-  NodePlatform,
-  NodeArch,
-  platforms,
-  architectures,
-  NexeTarget,
-  getTarget,
-  targetsEqual
-} from './target'
+import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target'
 export { NexeTarget }
 
+const versionsToSkip = [0, 1, 2, 3, 4, 5, 7, 9, 11]
 export interface GitAsset {
   name: string
   url: string
@@ -32,21 +24,15 @@ async function getJson<T>(url: string, options?: any) {
   return JSON.parse((await got(url, options)).body) as T
 }
 
-//TODO only build the latest of each major...?
 function isBuildableVersion(version: string) {
-  const major = +version.split('.')[0]
-  return !~[0, 1, 2, 3, 4, 5, 7].indexOf(major) || version === '4.8.4'
+  const major = Number(version.split('.')[0])
+  return !versionsToSkip.includes(major) || version === '4.8.4'
 }
 
 export function getLatestGitRelease(options?: any) {
   return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
 }
 
-export async function storeAsset(asset: GitAsset, dest: string, headers?: any) {
-  const options = headers ? { headers } : undefined
-  await download(asset.browser_download_url, dest, options as any)
-}
-
 export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
     'https://nodejs.org/download/release/index.json'
@@ -64,6 +50,7 @@ export async function getUnBuiltReleases(options?: any) {
       platforms.forEach(platform => {
         architectures.forEach(arch => {
           if (arch === 'x86' && platform === 'mac') return
+          if (arch.includes('arm')) return
           versions.push(getTarget({ platform, arch, version }))
         })
       })

src/steps/artifacts.ts

@@ -14,7 +14,7 @@ function readDirAsync(dir: string): Promise<string[]> {
     return Promise.all(
       paths.map((file: string) => {
         const path = join(dir, file)
-        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : path as any))
+        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : (path as any)))
       })
     ).then(result => {
       return [].concat(...(result as any))
@@ -39,7 +39,6 @@ function maybeReadFileContentsAsync(file: string) {
  *  - After the patch functions have run, the temporary directory is emptied
  *  - Original versions of sources to be patched are written to the temporary directory
  *  - Finally, The patched files are written into source.
- *
  */
 export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
   const { src } = compiler

src/steps/bundle.ts

@@ -0,0 +1,58 @@
+import { NexeCompiler, NexeError } from '../compiler'
+import { resolve, relative } from 'path'
+import { each } from '@calebboyd/semaphore'
+import resolveFiles from 'resolve-dependencies'
+import { dequote, STDIN_FLAG } from '../util'
+import { Readable } from 'stream'
+
+function getStdIn(stdin: Readable): Promise<string> {
+  return new Promise(resolve => {
+    let out = ''
+    stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        let current
+        while ((current = stdin.read())) {
+          out += current
+        }
+      })
+      .on('end', () => resolve(out))
+  })
+}
+
+export default async function bundle(compiler: NexeCompiler, next: any) {
+  const { bundle, cwd, input } = compiler.options
+  compiler.entrypoint = './' + relative(cwd, input)
+  compiler.startup = ';require("module").runMain();'
+
+  if (!bundle) {
+    await compiler.addResource(resolve(cwd, input))
+    return next()
+  }
+
+  let code = ''
+  if (typeof bundle === 'string') {
+    code = await require(bundle).createBundle(compiler.options)
+  }
+
+  if (input === STDIN_FLAG) {
+    compiler.stdinUsed = true
+    compiler.entrypoint = './__nexe_stdin.js'
+    code = code || dequote(await getStdIn(process.stdin))
+    await compiler.addResource(resolve(cwd, compiler.entrypoint), code)
+    return next()
+  }
+
+  const { files, warnings } = await resolveFiles(input, { cwd, expand: true, loadContent: false })
+
+  if (
+    warnings.filter(x => x.startsWith('Error parsing file') && !x.includes('node_modules')).length
+  ) {
+    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
+  }
+
+  await each(Object.keys(files), (filename: string) => compiler.addResource(filename), {
+    concurrency: 10
+  })
+  return next()
+}

src/steps/clean.ts

@@ -0,0 +1,19 @@
+import { NexeCompiler } from '../compiler'
+import { rimrafAsync } from '../util'
+import { NexeTarget } from '../target'
+
+export default async function clean(compiler: NexeCompiler, next: () => Promise<any>) {
+  const { options } = compiler
+  if (options.clean) {
+    let path = compiler.src
+    if (!options.build) {
+      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
+    }
+    const step = compiler.log.step('Cleaning up nexe build artifacts...')
+    step.log(`Deleting contents at: ${path}`)
+    await rimrafAsync(path)
+    step.log(`Deleted contents at: ${path}`)
+    return compiler.quit()
+  }
+  return next()
+}

src/steps/cli.ts

@@ -1,21 +1,8 @@
-import { normalize } from 'path'
-import { Readable } from 'stream'
-import { createWriteStream, chmodSync } from 'fs'
-import { readFileAsync, dequote, isWindows } from '../util'
+import { normalize, relative } from 'path'
+import { createWriteStream, chmodSync, statSync } from 'fs'
 import { NexeCompiler } from '../compiler'
 import { NexeTarget } from '../target'
-
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
-  return new Promise(resolve => {
-    let input = ''
-    stream.setEncoding('utf-8')
-    stream.on('data', (x: string) => {
-      input += x
-    })
-    stream.once('end', () => resolve(dequote(input)))
-    stream.resume && stream.resume()
-  })
-}
+import { STDIN_FLAG } from '../util'
 
 /**
  * The "cli" step detects the appropriate input. If no input options are passed,
@@ -23,29 +10,13 @@ function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
  * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
  *
  * Configuration:
- *   - compiler.options.input - file path to the input bundle.
- *     - fallbacks: stdin, package.json#main
- *   - compiler.options.output - file path to the output executable.
- *     - fallbacks: stdout, nexe_ + epoch + ext
  *
  * @param {*} compiler
  * @param {*} next
  */
 export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { output } = compiler.options
-  const { log, input: bundledInput } = compiler
-
-  if (!process.stdin.isTTY) {
-    log.step('Using stdin as input')
-    compiler.input = await readStreamAsync(process.stdin)
-  }
-
   await next()
-
-  compiler.output = isWindows
-    ? `${(output || compiler.options.name).replace(/\.exe$/, '')}.exe`
-    : `${output || compiler.options.name}`
-
+  const { log } = compiler
   const target = compiler.options.targets.shift() as NexeTarget
   const deliverable = await compiler.compileAsync(target)
 
@@ -58,8 +29,16 @@ export default async function cli(compiler: NexeCompiler, next: () => Promise<vo
         if (e) {
           reject(e)
         } else if (compiler.output) {
-          chmodSync(compiler.output, '755')
-          step.log(`Executable written to: ${compiler.output}`)
+          const output = compiler.output
+          const mode = statSync(output).mode | 0o111
+          chmodSync(output, mode.toString(8).slice(-3))
+          const inputFile = relative(process.cwd(), compiler.options.input)
+          const outputFile = relative(process.cwd(), output)
+          step.log(
+            `Entry: '${
+              compiler.stdinUsed ? (compiler.options.mangle ? STDIN_FLAG : '[none]') : inputFile
+            }' written to: ${outputFile}`
+          )
           resolve(compiler.quit())
         }
       })

src/steps/download.ts

@@ -12,7 +12,7 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
       let current = 0
       res.on('data', data => {
         current += data.length
-        setText(current / total * 100)
+        setText((current / total) * 100)
         if (current === total) {
           step.log('Extracting Node...')
         }
@@ -27,8 +27,12 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
  * @param {*} next
  */
 export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src, log } = compiler
-  const { version, sourceUrl, downloadOptions } = compiler.options
+  const {
+    src,
+    log,
+    targets: [{ version }]
+  } = compiler
+  const { sourceUrl, downloadOptions } = compiler.options
   const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
   const step = log.step(`Downloading Node.js source from: ${url}`)
   if (await pathExistsAsync(src)) {

src/steps/resource.ts

@@ -1,32 +1,22 @@
-import { readFileAsync, isDirectoryAsync, each } from '../util'
-import { Buffer } from 'buffer'
+import { isDirectoryAsync, each } from '../util'
 import * as globs from 'globby'
 import { NexeCompiler } from '../compiler'
 
-export default async function resource(compiler: NexeCompiler, next: () => Promise<void>) {
-  const resources = compiler.resources
-
+export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
+  const { cwd } = compiler.options
   if (!compiler.options.resources.length) {
     return next()
   }
   const step = compiler.log.step('Bundling Resources...')
   let count = 0
-  await each(globs(compiler.options.resources), async file => {
+  await each(globs(compiler.options.resources, { cwd }), async file => {
     if (await isDirectoryAsync(file)) {
       return
     }
     count++
     step.log(`Including file: ${file}`)
-    const contents = await readFileAsync(file)
-    const commentSafeContents = contents.toString('base64')
-    resources.index[file] = [
-      Buffer.byteLength(resources.bundle),
-      Buffer.byteLength(commentSafeContents)
-    ]
-    resources.bundle += commentSafeContents
+    await compiler.addResource(file)
   })
-  step.log(
-    `Included ${count} file(s). ${(Buffer.byteLength(resources.bundle) / 1e6).toFixed(3)} MB`
-  )
+  step.log(`Included ${count} file(s). ${(compiler.resourceSize / 1e6).toFixed(3)} MB`)
   return next()
 }

src/steps/shim.ts

@@ -0,0 +1,31 @@
+import { NexeCompiler } from '../compiler'
+import { wrap } from '../util'
+
+export default function(compiler: NexeCompiler, next: () => Promise<void>) {
+  compiler.shims.push(
+    wrap(
+      `process.__nexe = ${JSON.stringify(compiler.binaryConfiguration)};\n` +
+        '{{replace:lib/fs/patch.js}}' +
+        '\nshimFs(process.__nexe)'
+    )
+  )
+  compiler.shims.push(
+    wrap(`
+    if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
+      const cluster = require('cluster')
+      cluster._setupWorker()
+      delete process.env.NODE_UNIQUE_ID
+    }
+  `)
+  )
+
+  compiler.shims.push(
+    wrap(`
+      if (!process.send) {
+        process.argv.splice(1,0, require.resolve(${JSON.stringify(compiler.entrypoint)}))  
+      }
+    `)
+  )
+
+  return next()
+}

src/target.ts

@@ -1,21 +1,21 @@
 export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = 'x86' | 'x64'
+export type NodeArch = 'x86' | 'x64' | 'arm7l' | 'arm6l' | 'arm64'
 
 const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ['x86', 'x64']
+  architectures: NodeArch[] = ['x86', 'x64', 'arm7l', 'arm6l', 'arm64']
 
 export { platforms, architectures }
 
 export interface NexeTarget {
   version: string
-  platform: NodePlatform
-  arch: NodeArch
+  platform: NodePlatform | string
+  arch: NodeArch | string
 }
 
-//TODO bsd
 const prettyPlatform: { [key: string]: NodePlatform } = {
   win32: 'windows',
   windows: 'windows',
+  win: 'windows',
   darwin: 'mac',
   macos: 'mac',
   mac: 'mac',
@@ -24,9 +24,15 @@ const prettyPlatform: { [key: string]: NodePlatform } = {
   alpine: 'alpine'
 }
 
-//TODO arm
 const prettyArch: { [key: string]: NodeArch } = {
   x86: 'x86',
+  arm6: 'arm6l',
+  arm64: 'arm64',
+  arm6l: 'arm6l',
+  arm: 'arm7l',
+  arm7: 'arm7l',
+  arm7l: 'arm7l',
+  amd64: 'x64',
   ia32: 'x86',
   x32: 'x86',
   x64: 'x64'
@@ -36,7 +42,7 @@ function isVersion(x: string) {
   if (!x) {
     return false
   }
-  return /\d/.test(x.replace(/v|\./g, ''))
+  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
 }
 
 function isPlatform(x: string): x is NodePlatform {
@@ -61,8 +67,9 @@ export function targetsEqual(a: NexeTarget, b: NexeTarget) {
   return a.arch === b.arch && a.platform === b.platform && a.version === b.version
 }
 
-export function getTarget(target: string | NexeTarget = ''): NexeTarget {
-  let arch = process.arch as NodeArch,
+export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
+  const currentArch = process.arch
+  let arch = currentArch in prettyArch ? prettyArch[process.arch] : (process.arch as NodeArch),
     platform = prettyPlatform[process.platform],
     version = process.version.slice(1)
 
@@ -75,7 +82,7 @@ export function getTarget(target: string | NexeTarget = ''): NexeTarget {
     .split('-')
     .forEach(x => {
       if (isVersion(x)) {
-        version = x
+        version = x.replace(/v/g, '')
       }
       if (isPlatform(x)) {
         platform = prettyPlatform[x]

src/types.d.ts

@@ -3,8 +3,8 @@ declare module 'got' {
     (url: string, options?: any): Promise<{ body: string }>
     stream(url: string, optoins?: any): any
   }
-  function got(url: string, options?: any): Promise<{ body: string }>
-  export = got as GotFn
+  const got: GotFn
+  export = got
 }
 declare module 'download' {
   import { Duplex } from 'stream'

src/util.ts

@@ -4,15 +4,18 @@ import pify = require('pify')
 import rimraf = require('rimraf')
 
 const rimrafAsync = pify(rimraf)
+export const STDIN_FLAG = '[stdin]'
 
 export async function each<T>(
   list: T[] | Promise<T[]>,
   action: (item: T, index: number, list: T[]) => Promise<any>
 ) {
   const l = await list
-  for (let i = 0; i < l.length; i++) {
-    await action(l[i], i, l)
-  }
+  return Promise.all(l.map(action))
+}
+
+export function wrap(code: string) {
+  return '!(function () {' + code + '})();'
 }
 
 function falseOnEnoent(e: any) {
@@ -22,6 +25,30 @@ function falseOnEnoent(e: any) {
   throw e
 }
 
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).substr(0, l)
+}
+
+const bound: MethodDecorator = function bound<T>(
+  target: Object,
+  propertyKey: string | Symbol,
+  descriptor: TypedPropertyDescriptor<T>
+) {
+  const configurable = true
+  return {
+    configurable,
+    get(this: T) {
+      const value = (descriptor.value as any).bind(this)
+      Object.defineProperty(this, propertyKey as string, {
+        configurable,
+        value,
+        writable: true
+      })
+      return value
+    }
+  }
+}
+
 function dequote(input: string) {
   input = input.trim()
   const singleQuote = input.startsWith("'") && input.endsWith("'")
@@ -54,9 +81,27 @@ function isDirectoryAsync(path: string) {
     .then(x => x.isDirectory())
     .catch(falseOnEnoent)
 }
+/**
+ * @param version See if this version is greather than the second one
+ * @param operand Version to compare against
+ */
+function semverGt(version: string, operand: string) {
+  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
+  let [major, minor, patch] = operand.split('.').map(Number)
+  if (!minor) minor = 0
+  if (!patch) patch = 0
+  return (
+    cMajor > major ||
+    (cMajor === major && cMinor > minor) ||
+    (cMajor === major && cMinor === minor && cPatch > patch)
+  )
+}
 
 export {
   dequote,
+  padRight,
+  semverGt,
+  bound,
   isWindows,
   rimrafAsync,
   statAsync,

tasks/asset-compile.ts

@@ -1,24 +1,23 @@
-import * as nexe from '../src/nexe'
-import {
-  getUnBuiltReleases,
-  getLatestGitRelease
-} from '../src/releases'
+import * as nexe from '../lib/nexe'
+import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
 import * as ci from './ci'
-import { runAlpineBuild } from './docker'
-import { getTarget } from '../src/target'
-import { pathExistsAsync, statAsync, readFileAsync, execFileAsync } from '../src/util'
+import { runDockerBuild } from './docker'
+import { getTarget } from '../lib/target'
+import { pathExistsAsync, readFileAsync, execFileAsync } from '../lib/util'
 import got = require('got')
 
 const env = process.env,
   branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
   isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isLinux = Boolean(env.TRAVIS),
   isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.CIRCLECI),
-  isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
-    || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
-    || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = { 'Authorization': 'token ' + env.GITHUB_TOKEN }
+  isPullRequest =
+    Boolean(env.CIRCLE_PR_NUMBER) ||
+    Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) ||
+    Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
+  headers = {
+    Authorization: 'token ' + env.GITHUB_TOKEN,
+    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
+  }
 
 if (require.main === module) {
   if (!isPullRequest) {
@@ -29,7 +28,7 @@ if (require.main === module) {
   }
 }
 
-async function build () {
+async function build() {
   if (isScheduled) {
     const releases = await getUnBuiltReleases({ headers })
     if (!releases.length) {
@@ -51,25 +50,23 @@ async function build () {
   }
 
   if (env.NEXE_VERSION) {
-    const
-      target = getTarget(env.NEXE_VERSION),
+    const target = getTarget(env.NEXE_VERSION),
       output = isWindows ? './out.exe' : './out',
       options = {
         empty: true,
         build: true,
-        target, //FIXME
+        target,
         output
       }
-    
+    console.log('Building: ', target)
     const stop = keepalive()
-    if (target.platform === 'alpine') {
-      await runAlpineBuild(target, nexe.version.split('.')[0])
+    if (['arm7l', 'arm6l', 'arm64', 'alpine'].includes(target.platform)) {
+      await runDockerBuild(target)
     } else {
-      await nexe.compile(options)      
+      await nexe.compile(options)
     }
     stop()
-    
-    
+
     if (await pathExistsAsync(output)) {
       await assertNexeBinary(output)
       const gitRelease = await getLatestGitRelease({ headers })
@@ -77,21 +74,24 @@ async function build () {
         query: { name: target.toString() },
         body: await readFileAsync(output),
         headers: {
-          'Authorization': 'token ' + env.GITHUB_TOKEN,
+          ...headers,
           'Content-Type': 'application/octet-stream'
         }
+      }).catch(reason => {
+        console.log(reason && reason.response && reason.response.body)
+        throw reason
       })
       console.log(target + ' uploaded.')
     }
   }
 }
 
-function keepalive () {
+function keepalive() {
   const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
   return () => clearInterval(keepalive)
 }
 
-function assertNexeBinary (file: string) {
+function assertNexeBinary(file: string) {
   return execFileAsync(file).catch(e => {
     if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
       return

tasks/ci.ts

@@ -1,8 +1,24 @@
-import { NexeTarget } from '../src/releases'
+import { NexeTarget } from '../lib/releases'
 import got = require('got')
 import * as assert from 'assert'
+import { getTarget } from '../lib/target'
 const { env } = process
 
+export function triggerMacBuild(release: NexeTarget, branch: string) {
+  assert.ok(env.CIRCLE_TOKEN)
+  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${
+    env.CIRCLE_TOKEN
+  }`
+  return got(circle, {
+    json: true,
+    body: {
+      build_parameters: {
+        NEXE_VERSION: release.toString()
+      }
+    }
+  })
+}
+
 export function triggerDockerBuild(release: NexeTarget, branch: string) {
   assert.ok(env.TRAVIS_TOKEN)
   const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
@@ -14,35 +30,29 @@ export function triggerDockerBuild(release: NexeTarget, branch: string) {
         config: {
           merge_mode: 'deep_merge',
           env: {
-            NEXE_VERSION: release
+            //use matrix so that secure global variable is merged
+            matrix: {
+              NEXE_VERSION: release.toString()
+            }
           }
         }
       }
     },
     headers: {
       'Travis-API-Version': '3',
-      'Authorization': `token ${env.TRAVIS_TOKEN}`
+      Authorization: `token ${env.TRAVIS_TOKEN}`
     }
   })
 }
 
-export function triggerMacBuild (release: NexeTarget, branch: string) {
-  assert.ok(env.CIRCLE_TOKEN)
-  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
-  return got(circle, {
-    json: true,
-    body: {
-      build_parameters: {
-        NEXE_VERSION: release.toString()
-      }
+export function triggerWindowsBuild(release: NexeTarget) {
+  const version = 'NEXE_VERSION' in env ? env.NEXE_VERSION!.trim() : release.toString()
+  if (getTarget(version).version.startsWith('10.')) {
+    if ((env.APPVEYOR_BUILD_WORKER_IMAGE || '').includes('2017')) {
+      env.NEXE_VERSION = version
     }
-  })
-}
-
-export function triggerWindowsBuild (release: NexeTarget) {
-  const hasVersion = 'NEXE_VERSION' in env
-  env.NEXE_VERSION = hasVersion 
-    ? env.NEXE_VERSION!.trim() 
-    : release.toString() 
+  } else {
+    env.NEXE_VERSION = version
+  }
   return Promise.resolve()
 }

tasks/docker.ts

@@ -1,32 +1,72 @@
-import { NexeTarget } from '../src/target'
-import { writeFileAsync } from '../src/util'
-import exec = require('execa')
+import { NexeTarget, architectures } from '../lib/target'
+import { writeFileAsync, readFileAsync } from '../lib/util'
+import got = require('got')
+import execa = require('execa')
+import { appendFileSync } from 'fs'
 
-function alpine (target: NexeTarget, nexeVersion: string) {
-  const version = target.version
+function alpine(target: NexeTarget) {
   return `
-FROM i386/alpine:3.6
+FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.4
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
+ENV NODE_VERSION=${target.version}
+ENV NEXE_VERSION=beta
 WORKDIR /
-RUN curl -sSL https://nodejs.org/dist/v${version}/node-v${version}.tar.gz | tar -xz && \
-  cd /node-v${version} && \
+
+RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
+  mkdir /nexe_temp && mv /node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+  cd /nexe_temp/\${NODE_VERSION} && \
   ./configure --prefix=/usr --fully-static && \
-  make -j$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
-  make install && \
+  make && make install && \
   paxctl -cm /usr/bin/node
 
-RUN mkdir nexe_temp && mv node-v${version} nexe_temp/${version}
-RUN npm i nexe@beta -g
-ENV NEXE_TEMP=/nexe_temp
-
-RUN nexe --empty -c="--fully-static" -o /nexe-out`.trim()
+RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
+  npm install -g nexe@\${NEXE_VERSION} && \
+  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out --enableStdIn=false
+`.trim()
 }
 
-export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
-  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
-  const option = { stido: 'inherit' } as any
-  await exec('docker', ['build', '-t', 'nexe-alpine', '.'], option)
-  await exec('docker', ['run', '--name', 'nexe', 'nexe-alpine'], option)
-  await exec('docker', ['cp', 'nexe:/nexe-out', 'out'], option)
-  await exec('docker', ['rm', 'nexe'], option)
+function arm(target: NexeTarget) {
+  return `
+FROM hypriot/rpi-node
+ENV NEXE_VERSION=beta
+WORKDIR /
+
+RUN yarn global add nexe@\${NEXE_VERSION} && \
+  nexe --build --empty -o out -t ${target.version}
+`.trim()
+}
+
+export async function runDockerBuild(target: NexeTarget) {
+  //todo switch on alpine and arm
+  const dockerfile = alpine(target)
+  await writeFileAsync('Dockerfile', dockerfile)
+  const outFilename = 'nexe-docker-build-log.txt'
+  await writeFileAsync(outFilename, '')
+  let output: any = []
+
+  try {
+    output.push(await execa.shell(`docker build -t nexe-docker .`))
+    output.push(await execa.shell(`docker run -d --name nexe nexe-docker sh`))
+    output.push(await execa.shell(`docker cp nexe:/out out`))
+    output.push(await execa.shell(`docker rm nexe`))
+  } catch (e) {
+    console.log('Error running docker')
+    appendFileSync(outFilename, e.message)
+  } finally {
+    output.forEach((x: any) => {
+      appendFileSync(outFilename, x.stderr)
+      appendFileSync(outFilename, x.stdout)
+    })
+    await got(
+      `https://transfer.sh/${Math.random()
+        .toString(36)
+        .substring(2)}.txt`,
+      {
+        body: await readFileAsync(outFilename),
+        method: 'PUT'
+      }
+    )
+      .then(x => console.log('Posted docker log: ', x.body))
+      .catch(e => console.log('Error posting log', e))
+  }
 }

tasks/post-build.ts

@@ -0,0 +1,38 @@
+import { writeFileSync, readFileSync } from 'fs'
+
+/**
+ * post build step to insert code files into code files (naively).
+ * '{{replace:path/to/file}}' => "file contents"
+ * And the package.json version.
+ */
+//inject('plugins/nexe-daemon/lib/index.js')
+cp('src/fs/package.json', 'lib/fs/package.json')
+cp('src/fs/bootstrap.js', 'lib/fs/bootstrap.js')
+cp('src/fs/README.md', 'lib/fs/README.md')
+
+inject('lib/patches/third-party-main.js')
+inject('lib/steps/shim.js')
+inject('lib/options.js', JSON.stringify(require('../package.json').version))
+
+function inject(filename: string, ...replacements: string[]) {
+  let contents = readFileSync(filename, 'utf8')
+  contents = contents.replace(/('{{(.*)}}')/g, (substring: string, ...matches: string[]) => {
+    if (!matches || !matches[1]) {
+      return substring
+    }
+    const [replace, file] = matches[1].split(':')
+    if (replace !== 'replace') {
+      return substring
+    }
+    console.log('Replacing: ', substring)
+    return replacements[+file] ? replacements[+file] : JSON.stringify(readFileSync(file, 'utf8'))
+  })
+  writeFileSync(filename, contents)
+  console.log(`Wrote: ${filename}`)
+}
+
+function cp(from: string, to: string) {
+  const file = readFileSync(from)
+  writeFileSync(to, file)
+  console.log('Copied: ', from, 'To: ', to)
+}

test/fixture/dependency.js

@@ -0,0 +1 @@
+module.exports = 'abc'

test/fixture/entry.js

@@ -0,0 +1 @@
+console.log('hello world', require('./dependency'))

test/fixture/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "entry.js"
+}

test/mocha.opts

@@ -0,0 +1,4 @@
+./test/**/*.spec.ts
+--check-leaks
+--require ts-node/register
+--recursive

test/options.spec.ts

@@ -0,0 +1,56 @@
+import { normalizeOptions } from '../src/options'
+import { expect } from 'chai'
+import * as path from 'path'
+
+const ext = process.platform === 'win32' ? '.exe' : ''
+
+describe('options', () => {
+  describe('cwd', () => {
+    it('should use process.cwd() if nothing is provided', () => {
+      const options = normalizeOptions()
+      expect(options.cwd).to.equal(process.cwd())
+    })
+    it('should use the main module in a package directory', () => {
+      const options = normalizeOptions()
+      expect(options.input).to.equal(path.resolve('./index.js'))
+    })
+    it('should resolve relative paths for input', () => {
+      const options = normalizeOptions({ input: 'test/fixture/entry.js' })
+      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
+    })
+    it('should accept a module entry as input', () => {
+      const options = normalizeOptions({ input: 'test/fixture' })
+      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
+    })
+    it('should resolve pathed options against cwd', () => {
+      const cwd = path.join(process.cwd(), 'test/fixture')
+      const options = normalizeOptions({
+        cwd,
+        input: 'entry',
+        output: 'abc',
+        temp: './d'
+      })
+      expect(options.temp).to.equal(path.resolve(cwd, './d'))
+      expect(options.input).to.equal(path.resolve(cwd, 'entry.js'))
+      expect(options.output).to.equal(path.resolve(cwd, `abc${ext}`))
+    })
+  })
+  describe('output', () => {
+    it('should work', () => {
+      const options = normalizeOptions({
+        output: './some-output'
+      })
+      expect(options.output).to.equal(path.resolve(`./some-output${ext}`))
+    })
+    it('should default to the input file name if not index', () => {
+      const options = normalizeOptions({
+        input: './test/fixture'
+      })
+      expect(options.output).to.equal(path.resolve(`./entry${ext}`))
+    })
+    it('should default to the folder/project name if filename is index', () => {
+      const options = normalizeOptions({ cwd: './test/fixture2' })
+      expect(options.output).to.equal(path.resolve(`./test/fixture2/fixture2${ext}`))
+    })
+  })
+})

test/target.spec.ts

@@ -0,0 +1,29 @@
+import { padRight, isWindows } from '../src/util'
+import { expect } from 'chai'
+import chalk from 'chalk'
+import { getTarget, NexeTarget } from '../src/target'
+const b = chalk.blue
+const arch = process.arch === 'ia32' ? 'x86' : process.arch
+
+describe('Targets', () => {
+  ;[
+    ['win-ia32-6.11.2', 'windows-x86-6.11.2'],
+    [{ version: '6.11.2', platform: 'win', arch: 'ia32' }, 'windows-x86-6.11.2'],
+    ['win32-x64-6.11.2', 'windows-x64-6.11.2'],
+    ['win-amd64-6.11.2', 'windows-x64-6.11.2'],
+    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
+    ['macos-x64-v8.4.0', 'mac-x64-8.4.0'],
+    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
+    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
+    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
+    ['not-a-thing', getTarget(process).toString()]
+  ].forEach(([input, expected]) => {
+    it(`should accept: ${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
+      expect(getTarget(input).toString()).to.equal(expected)
+    })
+  })
+
+  it('should stringify and toString', () => {
+    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
+  })
+})

tsconfig.json

@@ -1,7 +1,9 @@
 {
   "compilerOptions": {
     "target":"es5",
-    "lib": ["es2017"],
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "lib": ["es2018"],
     "module": "commonjs",
     "outDir": "./lib",
     "strict": true

tslint.json

@@ -0,0 +1,9 @@
+{
+  "rulesDirectory": ["tslint-plugin-prettier", "tslint-config-prettier"],
+  "linterOptions": {
+    "exclude": ["**/node_modules/**/*"]
+  },  
+  "rules": {
+    "prettier": [true, { "semi": false, "printWidth": 100, "singleQuote": true }]
+  }
+}