chore: bump rc.9

chore: move mac build to circle
fix: ia32 target normalization
2017-09-28 00:15:44 -05:00 · 2017-09-27 23:36:52 -05:00 · 2017-09-27 01:34:07 -05:00 · 2017-09-27 00:47:16 -05:00 · 2017-09-26 23:54:18 -05:00 · 2017-09-26 20:16:03 -05:00
42 changed files with 5582 additions and 5689 deletions
@@ -4,6 +4,8 @@ coverage
 node_modules
 *.log
 *.exe
+*.bin
+!winsw.exe
 .idea
 .nexe
 lib
@@ -1,9 +1,9 @@
-os: osx
-language: node_js
-node_js:
- '6'
-script: npm run nexe-build
-env:
-  - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
-notifications:
-  email: false
+language: node_js
+node_js:
+- '6'
+script: npm run asset-compile
+env:
+  global:
+    - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
+notifications:
+  email: false
@@ -7,7 +7,7 @@
  <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">
@@ -16,7 +16,6 @@

 ## 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 +27,42 @@

 ## 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 my-bundle.js --no-bundle -o app.exe`
+- `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 acceptbale 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,60 +76,56 @@ 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`
+    - Combination of platform-arch-version. e.g. `'win32-ia32-6.10.3'`
+      - each segment is optional, and will be merged with the current environment
+    - 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>`
+ - #### `make: 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>`
+ - #### `make: string[]`
    - Alias for `make` option
 - #### `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: `[]`
@@ -140,27 +137,42 @@ compile({
    - Path to a user provided icon to be used (Windows only).
 - #### `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:
+      ```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)
    - default: `false`
+  - #### `fakeArgv: boolean`
+    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`. 
 - #### `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)
+A plugin

 ### `NexeCompiler`

@@ -170,7 +182,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,10 +194,10 @@ 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)
+Take a look at the (windows) [example](examples/native-build/build.js)

 - [ ] Implement support `node-pre-gyp#find`.

@@ -193,6 +207,21 @@ Take a look at the [example](examples/native-build/build.js)
 ---|---|---|---
 [Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |

+## Contributing
+
+Building
+```
+$ git clone git@github.com:nexe/nexe.git
+$ cd nexe
+$ yarn
+```
+
+Testing
+```
+$ npm test
+```
+
+
 ### Former

 - [Craig Condon](http://crcn.codes/)
@@ -5,16 +5,13 @@ environment:
    secure: tR7HXYv3x97q90uvPrjUxKZh7R1+uqKct0HdEcqTbsg=
  GITHUB_TOKEN:
    secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
-branches:
-  except:
-    - master
 install:
  - ps: Install-Product node 6
-  - npm i
+  - yarn
 build: off
 test: off
 build_script:
-  - npm run nexe-build
+  - yarn run asset-compile
 artifacts:
  - path: .nexe\**\node.exe
 cache:
@@ -1,8 +1,3 @@
-machine:
-  node:
-    version: 6.11.2
-  services:
-    - docker
 test:
  override:
-    - npm run nexe-build
+    - npm run asset-compile
@@ -1,22 +1,13 @@
-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'
-        ]
-      }
-    })
-  ]
+const nexe = require('../..')
+nexe.compile({
+  output: 'native-build',
+  silent: true,
+  native: {
+    zmq: {
+      additionalFiles: [
+        '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
+      ]
+    }
+  }
 })
-fuse.bundle('app')
-    .target('server')
-    .instructions(`> index.js`)
-fuse.run()
+
@@ -8,7 +8,6 @@ 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')
@@ -4,15 +4,13 @@
  "description": "",
  "main": "index.js",
  "scripts": {
-    "bundle": "node build",
-    "build-windows": "nexe -i app.js -o app.exe"
+    "build": "node build"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
+    "sqlite3": "^3.1.10",
    "zmq": "^2.15.3"
  },
-  "devDependencies": {
-    "fuse-box": "^2.2.31"
-  }
+  "devDependencies": {}
 }
@@ -1,10 +1,19 @@
 #!/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((e) => {
+      process.stderr.write(eol + e.stack)
+    })
+  }
+} else {
+  module.exports = require('./lib/nexe')
 }
@@ -2,19 +2,20 @@
  "name": "nexe",
  "description": "Create a single executable out of your Node.js application",
  "license": "MIT",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.9",
  "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",
+    "asset-compile": "ts-node tasks/asset-compile",
    "prebuild": "rimraf lib && npm run lint",
    "prepublish": "npm test && npm run build",
    "test": "mocha test/**/*.spec.ts",
    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
-    "build": "tsc --declaration"
+    "build": "tsc --declaration",
+    "postbuild": "ts-node tasks/post-build"
  },
  "repository": {
    "type": "git",
@@ -24,6 +25,7 @@
    "lib",
    "source-map-support.js"
  ],
+  "typings": "lib/nexe.d.ts",
  "main": "index.js",
  "bin": {
    "nexe": "index.js"
@@ -45,9 +47,9 @@
    "uglify-js": "3.0.28"
  },
  "devDependencies": {
-    "@types/bluebird": "^3.5.8",
    "@types/chai": "^4.0.4",
    "@types/chalk": "^0.4.31",
+    "@types/execa": "^0.7.0",
    "@types/globby": "^0.6.0",
    "@types/minimist": "^1.2.0",
    "@types/mkdirp": "^0.3.29",
@@ -56,6 +58,7 @@
    "@types/pify": "0.0.28",
    "@types/rimraf": "0.0.28",
    "chai": "^4.1.2",
+    "execa": "^0.8.0",
    "got": "^7.1.0",
    "mocha": "^3.5.0",
    "prettier": "^1.6.1",
@@ -0,0 +1,22 @@
+{
+  "name": "nexe-daemon",
+  "version": "1.0.0",
+  "description": "Plugin for nexe to create installable services",
+  "main": "index.js",
+  "scripts": {
+    "clean": "rimraf *.js",
+    "build": "tsc",
+    "postpublish": "npm run clean"
+  },
+  "files": [
+    "*.js",
+    "winsw.exe"
+  ],
+  "author": "Caleb Boyd",
+  "license": "MIT",
+  "devDependencies": {
+    "nexe": "^2.0.0-rc.6",
+    "rimraf": "^2.6.2",
+    "typescript": "^2.5.2"
+  }
+}
@@ -0,0 +1,50 @@
+import { NexeCompiler, NexeOptions } from 'nexe'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+interface NexeDaemonOptions {
+  id: string
+  name: string
+  description: string
+  executable: string
+}
+
+type DaemonOptions = NexeOptions & { daemon: { windows: NexeDaemonOptions } }
+
+function renderWinswConfig(options: any) {
+  return '<configuration>\r\n' +
+    `${Object.keys(options).reduce((config: string, element: string) => {
+      return config += `<${element}>${options[element]}</${element}>\r\n`
+    }, '')}</configuration>\r\n`
+}
+
+export default function daemon (compiler: NexeCompiler<DaemonOptions>, next: () => Promise<void>) {
+  if (compiler.target.platform !== 'windows') {
+    return next()
+  }
+  
+  compiler.addResource(
+    './nexe/plugin/daemon/winsw.exe',
+    readFileSync(require.resolve('./winsw.exe'))
+  )  
+  const name = compiler.options.name,
+    options = compiler.options.daemon.windows,
+    defaults: NexeDaemonOptions = {
+      id: name,
+      name,
+      description: name,
+      executable: '%BASE%\\' + compiler.output
+    } 
+
+  compiler.addResource(
+    './nexe/plugin/daemon/winsw-config.xml',
+    Buffer.from(renderWinswConfig(Object.assign(defaults, options)))
+  )
+  compiler.addResource(
+    './nexe/plugin/daemon/app.js',
+    Buffer.from(compiler.input)
+  )
+  compiler.input = '{{replace:plugins/nexe-daemon/lib/nexe-daemon.js}}'
+
+  return next()
+}
@@ -0,0 +1,4 @@
+console.log('hello world')
+if (true) {
+  console.log('wat')
+}
@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": [ "es2016" ],
+    "outDir": "lib",
+    "strict": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": []
+}
@@ -20,9 +20,8 @@ export function embedDotNode(
  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 modulePathParts = file.absPath.split(path.sep).reverse()
+  const module = modulePathParts[modulePathParts.findIndex(x => x === 'node_modules') - 1]
  const bindingName = path.basename(file.absPath)
  const settings = options[module]
  const moduleDir = hashName(contents)
@@ -31,7 +30,7 @@ export function embedDotNode(
    '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) {
+  if (!settings || settings === true) {
    file.contents += `
      mkdirp('${moduleDir}');
      var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
@@ -105,13 +104,13 @@ export class BindingsRewrite {
  public nativeModulePaths: string[] = []
  public rewrite = false

-  isRequireBindings(node: any) {
-    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
+  isRequire(node: any, moduleName: string) {
+    return node.callee.name === 'require' && node.arguments[0].value === moduleName
  }

  onNode(absolutePath: string, node: any, parent: any) {
    if (node.type === 'CallExpression') {
-      if (this.isRequireBindings(node) && parent.type === 'VariableDeclarator') {
+      if (this.isRequire(node, 'bindings') && parent.type === 'VariableDeclarator') {
        /**
         * const loadBindings = require('bindings');
         *   -> const loadBindings = String('');
@@ -123,7 +122,7 @@ export class BindingsRewrite {
        return
      }

-      if (this.isRequireBindings(node) && parent.type === 'CallExpression') {
+      if (this.isRequire(node, 'bindings') && parent.type === 'CallExpression') {
        /**
         *const bindings = require('bindings')('native-module')....
         *  -> const bindings = require('./path/to/native/module.node').....
@@ -8,6 +8,7 @@ export interface FuseBoxFile {
    dependencies: string[]
    requiresRegeneration: boolean
  }
+  consume(): void
  loadContents(): void
  makeAnalysis(
    parsingOptions?: any,
@@ -20,19 +21,16 @@ export interface FuseBoxFile {
  ): void
 }

-export default function(options: ExtractNodeModuleOptions) {
+export default function(options: ExtractNodeModuleOptions = {}) {
  return new NativeModulePlugin(options)
 }

 export class NativeModulePlugin {
-  public test: RegExp
+  public test = /node_modules.*(\.js|\.node)$|\.node$/
  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$`)
-  }
+  constructor(public options = {}) {}

  init(context: any) {
    context.allowExtension('.node')
@@ -47,6 +45,7 @@ export class NativeModulePlugin {
    }

    const bindingsRewrite = new BindingsRewrite()
+
    file.makeAnalysis(null, {
      plugins: [
        {
@@ -5,8 +5,8 @@ import { createReadStream } from 'fs'
 import { Readable } from 'stream'
 import { spawn } from 'child_process'
 import { Logger } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
-import { NexeOptions, nexeVersion } from './options'
+import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows, bound } from './util'
+import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
 import download = require('download')
 import { getLatestGitRelease } from './releases'
@@ -22,39 +22,43 @@ export interface NexeFile {
  contents: string
 }

+export { NexeOptions }
+
 interface NexeHeader {
  resources: { [key: string]: number[] }
  version: string
 }

-export class NexeCompiler {
+export class NexeCompiler<T extends NexeOptions = NexeOptions> {
  private start = Date.now()
  private env = { ...process.env }
  private compileStep: { modify: Function; log: Function }
  public log = new Logger(this.options.loglevel)
-  public src = join(this.options.temp, this.options.version)
+  public src: string
  public files: NexeFile[] = []
+  public shims: string[] = []
  public input: string
  public bundledInput?: string
-  public output: string | null
  public targets: NexeTarget[]
-  public resources: { bundle: string; index: { [key: string]: number[] } } = {
+  public target: NexeTarget
+  public resources: { bundle: Buffer; index: { [key: string]: number[] } } = {
    index: {},
-    bundle: ''
+    bundle: Buffer.from('')
  }
-  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>
+  public output = isWindows
+    ? `${(this.options.output || this.options.name).replace(/\.exe$/, '')}.exe`
+    : `${this.options.output || this.options.name}`

-  private nodeSrcBinPath = isWindows
-    ? join(this.src, 'Release', 'node.exe')
-    : join(this.src, 'out', 'Release', 'node')
-
-  constructor(public options: NexeOptions) {
+  private nodeSrcBinPath: string
+  constructor(public options: T) {
    const { python } = (this.options = options)
    this.targets = options.targets as NexeTarget[]
-    this.log.step('nexe ' + nexeVersion, 'info')
+    this.target = this.targets[0]
+    this.src = join(this.options.temp, this.target.version)
+    this.nodeSrcBinPath = isWindows
+      ? join(this.src, 'Release', 'node.exe')
+      : join(this.src, 'out', 'Release', 'node')
+    this.log.step('nexe ' + version, 'info')
    if (python) {
      if (isWindows) {
        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
@@ -62,40 +66,64 @@ export class NexeCompiler {
        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)
+  @bound
+  addResource(file: string, contents: Buffer) {
+    const { resources } = this
+    resources.index[file] = [resources.bundle.byteLength, contents.byteLength]
+    resources.bundle = Buffer.concat([resources.bundle, contents])
+  }
+
+  @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
+        })
      }
-      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.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) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = entry.contents.replace(replace, value)
+  }
+
+  @bound
+  async setFileContentsAsync(file: string, contents: string) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = contents
  }

  quit() {
    const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
+    this.log.write(`Finished in ${time / 1000}s`)
    return this.log.flush()
  }

+  assertBuild() {
+    if (!this.options.build) {
+      throw new Error('This feature is only available with `--build`')
+    }
+  }
+
  public getNodeExecutableLocation(target?: NexeTarget) {
    if (target) {
      return join(this.options.temp, target.toString())
@@ -111,7 +139,13 @@ export class NexeCompiler {
        stdio: 'ignore'
      })
        .once('error', reject)
-        .once('close', resolve)
+        .once('close', (code: number) => {
+          if (code != 0) {
+            const error = `${command} ${args.join(' ')} exited with code: ${code}`
+            reject(new Error(error))
+          }
+          resolve()
+        })
    })
  }

@@ -166,7 +200,7 @@ export class NexeCompiler {
    return createReadStream(filename)
  }

-  private _generateHeader() {
+  getHeader() {
    const version =
      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
        return (a += (this.options as any)[c]
@@ -180,20 +214,14 @@ export class NexeCompiler {
        .update(version)
        .digest('hex')
    }
-    const serializedHeader = this._serializeHeader(header)
-    return header
-  }
-
-  private _serializeHeader(header: NexeHeader) {
    return `process.__nexe=${JSON.stringify(header)};`
  }

  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 (!build && !binary) {
      step.modify('Fetching prebuilt binary')
      binary = await this._fetchPrebuiltBinaryAsync(target)
@@ -202,10 +230,10 @@ export class NexeCompiler {
      binary = await this._buildAsync()
      step.log('Node binary compiled')
    }
-    return this._assembleDeliverable(header, binary)
+    return this._assembleDeliverable(binary)
  }

-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
+  private _assembleDeliverable(binary: NodeJS.ReadableStream) {
    if (this.options.empty) {
      return binary
    }
@@ -214,12 +242,12 @@ export class NexeCompiler {
      artifact.push(chunk)
    })
    binary.on('close', () => {
-      const content = this._serializeHeader(header) + this.input
+      const content = [this.shims.join(''), this.input].join(';')
      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)
+      lengths.writeDoubleLE(this.resources.bundle.byteLength, 8)
      artifact.push(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
      artifact.push(null)
    })
@@ -1,16 +1,11 @@
-import { compose, PromiseConfig, Middleware } from 'app-builder'
+import { compose, Middleware } from 'app-builder'
 import resource from './steps/resource'
 import { NexeCompiler } from './compiler'
-import {
-  argv,
-  nexeVersion as version,
-  normalizeOptionsAsync,
-  NexeOptions,
-  NexePatch
-} from './options'
+import { argv, version, help, normalizeOptionsAsync, NexeOptions, NexePatch } from './options'
 import cli from './steps/cli'
 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'
@@ -39,7 +34,7 @@ async function compile(
  const buildSteps = build
    ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])]
    : []
-  const nexe = compose(resource, bundle, cli, buildSteps)
+  const nexe = compose(resource, bundle, cli, buildSteps, shim, options.plugins as NexePatch[])
  return callback
    ? void nexe(compiler).then(
        () => callback && callback(null),
@@ -51,4 +46,4 @@ async function compile(
    : nexe(compiler)
 }

-export { argv, compile, version }
+export { argv, compile, version, NexeCompiler, NexeOptions, help }
@@ -1,12 +1,12 @@
 import * as parseArgv from 'minimist'
 import { NexeCompiler } from './compiler'
 import { isWindows, padRight } from './util'
-import { basename, extname, join, isAbsolute, relative } from 'path'
+import { basename, extname, join, isAbsolute, relative, dirname } from 'path'
 import { getTarget, NexeTarget } from './target'
 import { EOL } from 'os'
-import * as chalk from 'chalk'
+import * as c from 'chalk'

-export const nexeVersion = '2.0.0-rc.3'
+export const version = '{{replace:0}}'

 export interface NexePatch {
  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -19,7 +19,6 @@ export interface NexeOptions {
  targets: (string | NexeTarget)[]
  name: string
  cwd: string
-  version: string
  flags: string[]
  configure: string[]
  vcBuild: string[]
@@ -31,11 +30,14 @@ export interface NexeOptions {
  enableNodeCli: boolean
  bundle: boolean | string
  patches: (string | NexePatch)[]
+  plugins: (string | NexePatch)[]
+  native: any
  empty: boolean
  sourceUrl?: string
  python?: string
  loglevel: 'info' | 'silent' | 'verbose'
  silent?: boolean
+  fakeArgv?: boolean
  verbose?: boolean
  info?: boolean
  ico?: string
@@ -50,7 +52,6 @@ export interface NexeOptions {
 }

 const defaults = {
-  version: process.version.slice(1),
  flags: [],
  cwd: process.cwd(),
  configure: [],
@@ -61,57 +62,67 @@ 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'
 }
 const argv = parseArgv(process.argv, { alias, default: defaults })
-const g = chalk.gray
-const help =
-  `
-nexe --help              CLI OPTIONS
+const g = c.gray
+let help = `
+${c.bold('nexe <entry-file> [options]')}

-  -i   --input      ${g('=index.js')}               -- application entry point
-  -o   --output     ${g('=my-app.exe')}             -- path to output file
-  -t   --target     ${g('=mac-x64-8.4.0')}          -- *target a prebuilt binary
-  -n   --name       ${g('=my-app')}                 -- main app module name
-  -v   --version    ${g(`=${padRight(process.version.slice(1), 23)}`)}-- node version
-  -p   --python     ${g('=/path/to/python2')}       -- python executable
-  -f   --flag       ${g('="--expose-gc"')}          -- *v8 flags to include during compilation
-  -c   --configure  ${g('="--with-dtrace"')}        -- *pass arguments to the configure step
-  -m   --make       ${g('="--loglevel"')}           -- *pass arguments to the make/build step
-  -s   --snapshot   ${g('=/path/to/snapshot')}      -- build with warmup snapshot
-  -r   --resource   ${g('=./paths/**/*')}           -- *embed file bytes within the binary
-  -b   --build                              -- build from source
-       --bundle     ${g('=./path/to/config')}       -- pass a module path that exports nexeBundle
-       --temp       ${g('=./path/to/temp')}         -- default './nexe'
-       --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
+       --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)
 }

@@ -139,7 +150,7 @@ function tryResolveMainFileName(cwd: string) {
    filename = basename(file).replace(extname(file), '')
  } catch (_) {}

-  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
+  return filename ? filename : 'nexe_' + Date.now()
 }

 function extractLogLevel(options: NexeOptions) {
@@ -149,12 +160,24 @@ 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') {
+  if (!isName(name) && typeof options.input === 'string') {
    name = basename(options.input).replace(extname(options.input), '')
  }
-  name = name || tryResolveMainFileName(options.cwd)
+
+  if (!isName(name)) {
+    name = tryResolveMainFileName(options.cwd)
+  }
+
+  if (!isName(name) && basename(options.cwd)) {
+    name = basename(options.cwd)
+  }
+
  return name.replace(/\.exe$/, '')
 }

@@ -182,28 +205,23 @@ function findInput(input: string, cwd: string) {
  return ''
 }

-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 normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions> {
  const options = Object.assign({}, defaults, input) as NexeOptions
  const opts = options as any

-  options.temp = process.env.NEXE_TEMP || join(options.cwd, '.nexe')
-  options.name = extractName(options)
+  options.temp = options.temp || process.env.NEXE_TEMP || join(options.cwd, '.nexe')
  options.input = findInput(options.input, options.cwd)
+  options.name = extractName(options)
  options.loglevel = extractLogLevel(options)
-  options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets).map(getTarget)
-  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)
+  options.make = flatten(options.vcBuild, options.make)
+  options.configure = flatten(options.configure)
+  options.resources = flatten(opts.resource, options.resources)
  options.rc = options.rc || extractCliMap(/^rc-.*/, options)

  if (!options.targets.length) {
-    options.targets = [getTarget(options.version)]
+    options.targets.push(getTarget())
  }

  if (options.build) {
@@ -215,14 +233,15 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
    }
  }

-  options.version = (options.targets[0] as NexeTarget).version
-
-  options.patches = options.patches.map(x => {
+  const requireDefault = (x: string) => {
    if (typeof x === 'string') {
      return require(x).default
    }
    return x
-  })
+  }
+
+  options.plugins = options.plugins.map(requireDefault)
+  options.patches = options.patches.map(requireDefault)

  Object.keys(alias)
    .filter(k => k !== 'rc')
@@ -231,4 +250,4 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
  return Promise.resolve(options)
 }

-export { argv, normalizeOptionsAsync }
+export { argv, normalizeOptionsAsync, help }
@@ -0,0 +1,53 @@
+const fs = require('fs')
+const fd = fs.openSync(process.execPath, 'r')
+const stat = fs.statSync(process.execPath)
+const footer = Buffer.from(Array(32))
+
+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)
+const resourceSize = footer.readDoubleLE(24)
+const contentStart = stat.size - 32 - resourceSize - contentSize
+const 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('__nexe cannot be reconfigured')
+        }
+        nexeHeader = Object.assign({}, value, {
+          layout: {
+            stat,
+            contentSize,
+            contentStart,
+            resourceSize,
+            resourceStart
+          }
+        })
+        Object.freeze(nexeHeader)
+      },
+      enumerable: false,
+      configurable: false
+    }
+  })()
+)
+
+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 as any)._compile(contentBuffer.toString(), process.execPath)
@@ -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()
  }

@@ -5,7 +5,7 @@ import cli from './disable-node-cli'
 import flags from './flags'
 import ico from './ico'
 import rc from './node-rc'
-import { NexeCompiler } from '../compiler'
+import { NexeCompiler, NexeOptions } from '../compiler'

 const patches = [gyp, nexePatches, buildFixes, cli, flags, ico, rc]

@@ -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()
@@ -5,122 +5,7 @@ import { join } from 'path'
 export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
  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()
 }
@@ -1,11 +1,13 @@
 import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
 import { readFileAsync, writeFileAsync } from '../util'
-//import NativeModulePlugin from './fuse-native-module-plugin'
+import { resolve, relative } from 'path'
+import NativeModulePlugin from '../bundling/fuse-native-module-plugin'
+import { NexeOptions } from '../options'

-function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
-  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
-  if (options.minify) {
+function createBundle(options: NexeOptions) {
+  const { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } = require('fuse-box')
+  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin(), NativeModulePlugin(options.native)]
+  if (options.compress) {
    plugins.push(
      QuantumPlugin({
        target: 'server',
@@ -16,7 +18,7 @@ function createBundle(filename: string, options: { name: string; minify: any; cw
  }
  const fuse = FuseBox.init({
    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
+    log: Boolean(process.env.NEXE_BUNDLE_LOG) || false,
    homeDir: options.cwd,
    sourceMaps: false,
    writeBundles: false,
@@ -24,10 +26,11 @@ function createBundle(filename: string, options: { name: string; minify: any; cw
    target: 'server',
    plugins
  })
-  fuse.bundle(options.name).instructions(`> ${filename}`)
-  return fuse.run().then(x => {
+  const input = relative(options.cwd, options.input).replace(/\\/g, '/')
+  fuse.bundle(options.name).instructions(`> ${input}`)
+  return fuse.run().then((x: any) => {
    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
+    x.bundles.forEach((y: any) => (output = y.context.output.lastPrimaryOutput.content.toString()))
    return output
  })
 }
@@ -45,16 +48,12 @@ export default async function bundle(compiler: NexeCompiler, next: any) {

  let producer = createBundle
  if (typeof compiler.options.bundle === 'string') {
-    producer = require(compiler.options.bundle).createBundle
+    producer = require(resolve(compiler.options.cwd, compiler.options.bundle)).createBundle
  }

-  compiler.input = await producer(compiler.options.input, {
-    cwd: compiler.options.cwd,
-    name: compiler.options.name,
-    minify: compiler.options.compress
-  })
+  compiler.input = await producer(compiler.options)

-  if (compiler.options.debugBundle) {
+  if ('string' === typeof compiler.options.debugBundle) {
    await writeFileAsync(compiler.options.debugBundle, compiler.input)
  }

@@ -32,20 +32,15 @@ function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
 * @param {*} next
 */
 export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { output } = compiler.options
-  const { log, input: bundledInput } = compiler
-
+  const { log } = compiler
+  let stdInUsed = false
  if (!process.stdin.isTTY) {
-    log.step('Using stdin as input')
+    stdInUsed = true
    compiler.input = await readStreamAsync(process.stdin)
  }

  await next()

-  compiler.output = isWindows
-    ? `${(output || compiler.options.name).replace(/\.exe$/, '')}.exe`
-    : `${output || compiler.options.name}`
-
  const target = compiler.options.targets.shift() as NexeTarget
  const deliverable = await compiler.compileAsync(target)

@@ -59,7 +54,11 @@ export default async function cli(compiler: NexeCompiler, next: () => Promise<vo
          reject(e)
        } else if (compiler.output) {
          chmodSync(compiler.output, '755')
-          step.log(`Executable written to: ${compiler.output}`)
+          step.log(
+            `Entry: '${stdInUsed
+              ? '[stdin]'
+              : compiler.options.input}' written to: ${compiler.output}`
+          )
          resolve(compiler.quit())
        }
      })
@@ -18,15 +18,8 @@ export default async function resource(compiler: NexeCompiler, next: () => Promi
    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
+    compiler.addResource(file, contents)
  })
-  step.log(
-    `Included ${count} file(s). ${(Buffer.byteLength(resources.bundle) / 1e6).toFixed(3)} MB`
-  )
+  step.log(`Included ${count} file(s). ${(resources.bundle.byteLength / 1e6).toFixed(3)} MB`)
  return next()
 }
@@ -0,0 +1,93 @@
+import { Stats } from 'fs'
+import { ok } from 'assert'
+import { resolve, normalize } from 'path'
+
+const binary = (process as any).__nexe as NexeBinary
+ok(binary)
+const manifest = binary.resources
+const isString = (x: any): x is string => typeof x === 'string' || x instanceof String
+
+if (Object.keys(manifest).length) {
+  const fs = require('fs')
+  const originalReadFile = fs.readFile
+  const originalReadFileSync = fs.readFileSync
+  const resourceStart = binary.layout.resourceStart
+
+  let setupManifest = () => {
+    const manifest = binary.resources
+    Object.keys(manifest).forEach(key => {
+      const absolutePath = resolve(key)
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = manifest[key]
+      }
+      const normalizedPath = normalize(key)
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[key]
+      }
+    })
+    setupManifest = () => {}
+  }
+  //TODO track inflight fs reqs??
+  var nfs = {
+    readFile: function readFile(file: any, options: any, callback: any) {
+      setupManifest()
+      const entry = manifest[file]
+      if (!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: 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)
+          })
+        })
+      })
+    },
+    readFileSync: function readFileSync(file: any, options: any) {
+      setupManifest()
+      const entry = manifest[file]
+      if (!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)
+      return encoding ? result.toString(encoding) : result
+    }
+  }
+  Object.assign(fs, nfs)
+}
+
+interface NexeBinary {
+  resources: { [key: string]: number[] }
+  version: string
+  layout: {
+    stat: Stats
+    contentSize: number
+    contentStart: number
+    resourceSize: number
+    resourceStart: number
+  }
+}
@@ -0,0 +1,25 @@
+import { NexeCompiler } from '../compiler'
+
+function wrap(code: string) {
+  return '!(function () {' + code + '})();'
+}
+
+export default function(compiler: NexeCompiler, next: () => Promise<void>) {
+  compiler.shims.push(wrap(compiler.getHeader()))
+
+  if (compiler.options.resources.length) {
+    compiler.shims.push(wrap('{{replace:lib/steps/shim-fs.js}}'))
+  }
+
+  if (compiler.options.fakeArgv) {
+    const nty = !process.stdin.isTTY
+    const input = nty ? '[stdin]' : compiler.options.input
+    compiler.shims.push(
+      wrap(`
+      var r = require('path').resolve; 
+      process.argv.splice(1,0, ${nty ? `'${input}'` : `r("${input}")`});`)
+    )
+  }
+
+  return next()
+}
@@ -63,7 +63,8 @@ export function targetsEqual(a: NexeTarget, b: NexeTarget) {
 }

 export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
-  let arch = process.arch as NodeArch,
+  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)

@@ -26,6 +26,22 @@ function padRight(str: string, l: number) {
  return (str + ' '.repeat(l)).substr(0, l)
 }

+const bound: MethodDecorator = function bound<T>(
+  target: Object,
+  propertyKey: string,
+  descriptor: TypedPropertyDescriptor<T>
+) {
+  const configurable = true
+  return {
+    configurable,
+    get(this: T) {
+      const value = (descriptor.value as any).bind(this)
+      Object.defineProperty(this, propertyKey, { configurable, value, writable: true })
+      return value
+    }
+  }
+}
+
 function dequote(input: string) {
  input = input.trim()
  const singleQuote = input.startsWith("'") && input.endsWith("'")
@@ -62,6 +78,7 @@ function isDirectoryAsync(path: string) {
 export {
  dequote,
  padRight,
+  bound,
  isWindows,
  rimrafAsync,
  statAsync,
@@ -1,20 +1,20 @@
-import * as nexe from '../src/nexe'
+import * as nexe from '../lib/nexe'
 import {
  getUnBuiltReleases,
  getLatestGitRelease
-} from '../src/releases'
+} 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 { getTarget } from '../lib/target'
+import { pathExistsAsync, statAsync, 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.CIRCLECI),
+  isLinux = Boolean(env.TRAVIS),
  isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.TRAVIS),
+  isMac = Boolean(env.CIRCLECI),
  isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
    || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
    || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
@@ -1,9 +1,23 @@
-import { NexeTarget } from '../src/releases'
+import { NexeTarget } from '../lib/releases'
 import got = require('got')
 import * as assert from 'assert'
 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`
  return got(travis, {
@@ -14,7 +28,10 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
        config: {
          merge_mode: 'deep_merge',
          env: {
-            NEXE_VERSION: release.toString()
+            //use matrix so that secure global variable is merged
+            matrix: {
+              NEXE_VERSION: release.toString()
+            }
          }
        }
      }
@@ -26,19 +43,6 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
  })
 }

-export function triggerDockerBuild (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 hasVersion = 'NEXE_VERSION' in env
  env.NEXE_VERSION = hasVersion 
@@ -1,73 +1,54 @@
-import { NexeTarget } from '../src/target'
-import { writeFileAsync, readFileAsync } from '../src/util'
+import { NexeTarget } from '../lib/target'
+import { writeFileAsync, readFileAsync } from '../lib/util'
 import { spawn } from 'child_process'
 import got = require('got')
-import { createWriteStream, WriteStream } from 'fs'
+import execa = require('execa')
+import { appendFileSync } from 'fs'

 function alpine (target: NexeTarget, nexeVersion: string) {  
  return `
-FROM i386/alpine:3.4
+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\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  cd /node-v\${NODE_VERSION} && \
+  mkdir /nexe_temp && mv /node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+  cd /nexe_temp/\${NODE_VERSION} && \
  ./configure --prefix=/usr --fully-static && \
-  make -j$(getconf _NPROCESSORS_ONLN) && \
-  make install && \
+  make && make install && \
  paxctl -cm /usr/bin/node

-RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+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
 `.trim()
 }

-export async function runAsync (command: string, output: WriteStream) {
-  const commands = command.split(/\r?\n/)
-    .filter(x => x.trim())
-    .map(x => x.trim().split(' '))
-  const sequence = Promise.resolve()
-  for (const command of commands) {
-    await new Promise((resolve, reject) => {
-      const cp = spawn(command.shift() as string, command)
-      cp.stderr.pipe(output)
-      cp.stdout.pipe(output)
-      const close = function (this: any, e: Error) {
-        this.kill()
-        e ? reject(e) : resolve()
-      }
-      cp.on('error', (e) => {
-        output.write(e.stack)
-      })
-      .on('close', close)
-      .on('exit', close)
-    })
-  }
-}
-
 export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
  const outFilename = 'nexe-alpine-build-log.txt'
-  const output = createWriteStream(outFilename)
+  await writeFileAsync(outFilename, '')
+  let output: any = []
+
  try {
-    await runAsync(`
-    docker build -t nexe-alpine .
-    docker run -d --name nexe nexe-alpine sh
-    docker cp nexe:/out out
-    docker rm nexe
-  `, output)
+    output.push(await execa.shell(`docker build -t nexe-alpine .`))    
+    output.push(await execa.shell(`docker run -d --name nexe nexe-alpine sh`))    
+    output.push(await execa.shell(`docker cp nexe:/out out`))    
+    output.push(await execa.shell(`docker rm nexe`))
  } catch(e) {
-    console.log(e)
+    console.log('Error running docker', e)
  } finally {
-    output.close()
+    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(x.body))
+    .then(x => console.log('Posted docker log: ', x.body))
    .catch(e => console.log('Error posting log', e))
  }
 }
@@ -0,0 +1,30 @@
+import { writeFileSync, readFileSync } from 'fs'
+
+/**
+ * post build step to insert code files into code files. 
+ * '{{replace:path/to/file}}' => "file contents"
+ * And the package.json version.
+ */
+//inject('plugins/nexe-daemon/lib/index.js')
+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}`)
+}
@@ -3,7 +3,7 @@ import { expect } from 'chai'
 import { blue as b } from 'chalk'
 import { getTarget, NexeTarget } from '../src/target'

-const arch = (isWindows && process.arch === 'ia32') ? 'x86' : process.arch
+const arch = process.arch === 'ia32' ? 'x86' : process.arch

 describe('Targets', () => {
  [
@@ -16,7 +16,7 @@ describe('Targets', () => {
    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
    ['not-a-thing', getTarget(process).toString()]
  ].forEach(([input, expected]) => {
-    it(`${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
+    it(`should accept: ${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
      expect(getTarget(input).toString()).to.equal(expected)
    })
  })
@@ -1,6 +1,7 @@
 {
  "compilerOptions": {
    "target":"es5",
+    "experimentalDecorators": true,
    "lib": ["es2017"],
    "module": "commonjs",
    "outDir": "./lib",
Author	SHA1	Message	Date
calebboyd	0d62d0100d	chore: bump rc.9	2017-09-28 00:15:44 -05:00
calebboyd	bfd07cd10a	chore: move mac build to circle	2017-09-27 23:36:52 -05:00
calebboyd	4390568654	fix: ia32 target normalization	2017-09-27 01:34:07 -05:00
calebboyd	5c9cf3580c	chore: update build	2017-09-27 00:47:16 -05:00
calebboyd	fcb54d9085	fix: check error code on build commands	2017-09-26 23:54:18 -05:00
calebboyd	11fa087e9d	refactor: move startup scripts to shims, add plugins	2017-09-26 20:16:03 -05:00
calebboyd	b822984776	fix: input path for bundle	2017-09-26 00:10:09 -05:00
calebboyd	4f2b1c51d5	refactor: addResource compiler method	2017-09-26 00:10:09 -05:00
Brian McCallister	dbcff4c7d2	fix: minor spelling problem	2017-09-21 18:04:07 -05:00
calebboyd	9906df8d55	chore: bump rc6	2017-09-13 19:08:44 -05:00
calebboyd	d685ec21e5	fix: custom bundle resolution	2017-09-13 19:07:54 -05:00
calebboyd	a2c4f3e9f1	fix: use cwd directory name for output resolution before timestring	2017-09-13 18:43:26 -05:00
calebboyd	79bcb753b4	fix: native module fuse plubin	2017-09-11 01:20:37 -05:00
calebboyd	bc2a637cc4	docs: cleanup	2017-09-10 20:18:37 -05:00
calebboyd	ad279e6daf	docs: clarify resource and build documentation	2017-09-09 14:08:04 -05:00
calebboyd	2b9a8b1f0e	feat: fake-argv option	2017-09-09 02:02:52 -05:00
calebboyd	7a7aaefa23	fix: set input before name (so name can derive from input)	2017-09-08 23:44:26 -05:00
calebboyd	04fdd165a4	feat: productversion and fileversion replacements in node-rc	2017-09-08 14:29:19 -05:00
calebboyd	455d6893fd	fix: cache for build vs target	2017-09-08 08:13:40 -05:00