chore: bump deps

.travis.yml

@@ -1,4 +1,7 @@
 language: node_js
+before_install:
+  - sudo apt-get -qq update
+  - sudo apt-get install -y g++-multilib
 node_js:
 - '6'
 script: npm run asset-compile

README.md

@@ -5,13 +5,14 @@
   <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>
+  <a href="https://gitter.im/nexe/nexe?utm_source=badge&utm_medium=badge"><img src="https://badges.gitter.im/nexe/nexe.svg"></a>
 </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
@@ -87,8 +88,17 @@ compile({
     - Output executable file path
     - default: same as `name` with an OS specific extension.
  - #### `target: string | object`
-    - Combination of platform-arch-version. e.g. `'win32-ia32-6.10.3'`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-6.10.3'`
       - each segment is optional, and will be merged with the current environment
+      - Examples: ([full list](https://github.com/nexe/nexe/releases))
+        - `'win32-x86-8.6.0`
+        - `{ platform: 'alpine' }`
+        - `darwin-8.6.0`
+        - `linux-x64`
+        - `macos-8.4.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
@@ -120,7 +130,7 @@ compile({
  - #### `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: string[]`
+ - #### `vcBuild: string[]`
     - Alias for `make` option
  - #### `snapshot: string`
     - path to a file to be used as the warmup snapshot for the build
@@ -171,8 +181,7 @@ compile({
 
 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
+For examples, see the built in patches: [src/patches](src/patches).
 
 ### `NexeCompiler`
 
@@ -196,16 +205,15 @@ Any modifications made to `NexeFile#contents` will be maintained in the cache _w
 
 ## 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 (windows) [example](examples/native-build/build.js)
+Any `.node` binding can be used with nexe. These library files will be bundled and written alongside the resulting binary at runtime. Currently, nexe supports modules loaded directly (`.node` files) and those loaded with the `'bindings'` module. It does not yet support modules using `node-pre-gyp#find`. 
 
-- [ ] Implement support `node-pre-gyp#find`.
+Its important to note: unless your native module conditionally loads each platform binary. Nexe builds with native modules will be platform specific. Eg. You will no longer be able to use cross platform builds. 
 
-## Maintainers
+Nexe builds with native modules will need to target the same version, platform and architecture as the platform hosting the module. At least until [N-API](https://github.com/nodejs/abi-stable-node) is fully propegated
 
-[![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) |
+TODO
+
+- [ ] Implement support for `node-pre-gyp#find`.
 
 ## Contributing
 
@@ -221,6 +229,11 @@ 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) |
 
 ### Former
 

package.json

@@ -2,7 +2,7 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "2.0.0-rc.9",
+  "version": "2.0.0-rc.15",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
@@ -10,10 +10,10 @@
   ],
   "scripts": {
     "asset-compile": "ts-node tasks/asset-compile",
-    "prebuild": "rimraf lib && npm run lint",
+    "test": "mocha",
+    "fmt": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"{src,plugins,tasks}/**/*.ts\"",
     "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\"",
+    "prebuild": "rimraf lib && npm run fmt",
     "build": "tsc --declaration",
     "postbuild": "ts-node tasks/post-build"
   },
@@ -37,7 +37,7 @@
     "app-builder": "^5.1.0",
     "chalk": "^1.1.3",
     "download": "^6.2.0",
-    "fuse-box": "2.2.31",
+    "fuse-box": "^2.3.4-beta.5",
     "globby": "^6.1.0",
     "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",

plugins/nexe-daemon/package.json

@@ -2,21 +2,23 @@
   "name": "nexe-daemon",
   "version": "1.0.0",
   "description": "Plugin for nexe to create installable services",
-  "main": "index.js",
+  "main": "lib/index.js",
   "scripts": {
     "clean": "rimraf *.js",
     "build": "tsc",
     "postpublish": "npm run clean"
   },
   "files": [
-    "*.js",
+    "lib",
     "winsw.exe"
   ],
   "author": "Caleb Boyd",
   "license": "MIT",
   "devDependencies": {
-    "nexe": "^2.0.0-rc.6",
     "rimraf": "^2.6.2",
     "typescript": "^2.5.2"
+  },
+  "dependencies": {
+    "nexe": "^2.0.0-rc.11"
   }
 }

plugins/nexe-daemon/src/index.ts

@@ -12,38 +12,36 @@ interface NexeDaemonOptions {
 type DaemonOptions = NexeOptions & { daemon: { windows: NexeDaemonOptions } }
 
 function renderWinswConfig(options: any) {
-  return '<configuration>\r\n' +
+  return (
+    '<configuration>\r\n' +
     `${Object.keys(options).reduce((config: string, element: string) => {
-      return config += `<${element}>${options[element]}</${element}>\r\n`
+      return (config += `<${element}>${options[element]}</${element}>\r\n`)
     }, '')}</configuration>\r\n`
+  )
 }
 
-export default function daemon (compiler: NexeCompiler<DaemonOptions>, next: () => Promise<void>) {
+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'))
-  )  
+    readFileSync(require.resolve('../winsw.exe'))
+  )
   const name = compiler.options.name,
-    options = compiler.options.daemon.windows,
+    options = (compiler.options.daemon && compiler.options.daemon.windows) || {},
     defaults: NexeDaemonOptions = {
       id: name,
       name,
       description: name,
       executable: '%BASE%\\' + compiler.output
-    } 
+    }
 
   compiler.addResource(
-    './nexe/plugin/daemon/winsw-config.xml',
+    './nexe/plugin/daemon/winsw.xml',
     Buffer.from(renderWinswConfig(Object.assign(defaults, options)))
   )
-  compiler.addResource(
-    './nexe/plugin/daemon/app.js',
-    Buffer.from(compiler.input)
-  )
+  compiler.addResource('./nexe/plugin/daemon/app.js', Buffer.from(compiler.input))
   compiler.input = '{{replace:plugins/nexe-daemon/lib/nexe-daemon.js}}'
 
   return next()

plugins/nexe-daemon/src/nexe-daemon.ts

@@ -1,4 +1,66 @@
-console.log('hello world')
-if (true) {
-  console.log('wat')
+const installCommands = ['-i', '--install']
+const installIndex = process.argv.findIndex(x => installCommands.includes(x))
+import * as path from 'path'
+import * as fs from 'fs'
+import * as cp from 'child_process'
+
+function mkdirp(r: string, t?: any): any {
+  ;(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 (~installIndex) {
+  console.log('DIRECTORY FOUND')
+  const directory = process.argv[installIndex + 1]
+  if (directory) {
+    mkdirp(path.dirname(directory))
+    const filename = path.join(directory, path.basename(process.execPath))
+    const readStream = fs.createReadStream(process.execPath)
+    const writeStream = fs.createWriteStream(filename)
+
+    const onError = function() {
+      readStream.removeAllListeners()
+      writeStream.removeAllListeners()
+      //TODO
+    }
+
+    readStream
+      .on('error', onError)
+      .pipe(writeStream)
+      .on('error', onError)
+      .on('close', () => {
+        const winsw = filename.replace('.exe', '-service.exe')
+        fs.writeFileSync(winsw, fs.readFileSync('./nexe/plugin/daemon/winsw.exe'))
+        fs.writeFileSync(
+          filename.replace('.exe', '-service.xml'),
+          fs.readFileSync('./nexe/plugin/daemon/winsw.xml')
+        )
+        installService(winsw)
+      })
+  }
+} else {
+  console.log('DIRECTORY NOT FOUND')
+  require('./nexe/plugin/daemon/app.js')
+}
+
+function installService(filename: string) {
+  cp.exec(filename + ' install', error => {
+    if (error && !error.message.includes('already exists')) {
+      throw error
+    }
+  })
 }

plugins/nexe-daemon/yarn.lock

@@ -1458,9 +1458,9 @@ negotiator@0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.1.tgz#2b327184e8992101177b28563fb5e7102acd0ca9"
 
-nexe@^2.0.0-rc.6:
-  version "2.0.0-rc.6"
-  resolved "https://registry.yarnpkg.com/nexe/-/nexe-2.0.0-rc.6.tgz#b3990bb67098a93bc488b21ad88aee67b62cf0d5"
+nexe@^2.0.0-rc.11:
+  version "2.0.0-rc.11"
+  resolved "https://registry.yarnpkg.com/nexe/-/nexe-2.0.0-rc.11.tgz#cd06fc91da8db008fffa6dde1a9a8dd6decf2c35"
   dependencies:
     app-builder "^5.1.0"
     chalk "^1.1.3"

src/bundling/bindings-rewrite.ts

@@ -3,74 +3,6 @@ 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 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)
-  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 || 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'

src/bundling/embed-node.ts

@@ -0,0 +1,71 @@
+import { createHash } from 'crypto'
+import * as path from 'path'
+
+export interface EmbedNodeModuleOptions {
+  [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: EmbedNodeModuleOptions,
+  file: { contents: string; absPath: string }
+) {
+  const contents = fs.readFileSync(file.absPath)
+  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)
+  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 || 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)
+  `
+}

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

@@ -1,4 +1,5 @@
-import { BindingsRewrite, embedDotNode, ExtractNodeModuleOptions } from './bindings-rewrite'
+import { BindingsRewrite } from './bindings-rewrite'
+import { embedDotNode, EmbedNodeModuleOptions } from './embed-node'
 
 export interface FuseBoxFile {
   info: { absPath: string }
@@ -21,14 +22,14 @@ export interface FuseBoxFile {
   ): void
 }
 
-export default function(options: ExtractNodeModuleOptions = {}) {
+export default function(options: EmbedNodeModuleOptions = {}) {
   return new NativeModulePlugin(options)
 }
 
 export class NativeModulePlugin {
   public test = /node_modules.*(\.js|\.node)$|\.node$/
   public limit2Project = false
-  private modules: (keyof ExtractNodeModuleOptions)[]
+  private modules: (keyof EmbedNodeModuleOptions)[]
 
   constructor(public options = {}) {}
 

src/compiler.ts

@@ -4,7 +4,7 @@ import { createHash } from 'crypto'
 import { createReadStream } from 'fs'
 import { Readable } from 'stream'
 import { spawn } from 'child_process'
-import { Logger } from './logger'
+import { Logger, LogStep } from './logger'
 import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows, bound } from './util'
 import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
@@ -32,7 +32,7 @@ interface NexeHeader {
 export class NexeCompiler<T extends NexeOptions = NexeOptions> {
   private start = Date.now()
   private env = { ...process.env }
-  private compileStep: { modify: Function; log: Function }
+  private compileStep: LogStep
   public log = new Logger(this.options.loglevel)
   public src: string
   public files: NexeFile[] = []
@@ -45,10 +45,7 @@ export class NexeCompiler<T extends NexeOptions = NexeOptions> {
     index: {},
     bundle: Buffer.from('')
   }
-  public output = isWindows
-    ? `${(this.options.output || this.options.name).replace(/\.exe$/, '')}.exe`
-    : `${this.options.output || this.options.name}`
-
+  public output = this.options.output
   private nodeSrcBinPath: string
   constructor(public options: T) {
     const { python } = (this.options = options)
@@ -132,14 +129,25 @@ export class NexeCompiler<T extends NexeOptions = NexeOptions> {
   }
 
   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('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 Error(error))
@@ -185,18 +193,17 @@ export class NexeCompiler<T extends NexeOptions = NexeOptions> {
       throw new Error(`${assetName} not available, create it using the --build flag`)
     }
     const filename = this.getNodeExecutableLocation(target)
-    await download(
-      asset.browser_download_url,
-      dirname(filename),
-      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()}%`)
-      })
-    })
+    await download(asset.browser_download_url, dirname(filename), 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)
   }
 

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,7 +1,7 @@
 import { compose, Middleware } from 'app-builder'
 import resource from './steps/resource'
 import { NexeCompiler } from './compiler'
-import { argv, version, help, normalizeOptionsAsync, NexeOptions, NexePatch } from './options'
+import { argv, version, help, normalizeOptions, NexeOptions, NexePatch } from './options'
 import cli from './steps/cli'
 import bundle from './steps/bundle'
 import download from './steps/download'
@@ -15,7 +15,7 @@ async function compile(
   compilerOptions?: Partial<NexeOptions>,
   callback?: (err: Error | null) => void
 ) {
-  const options = await normalizeOptionsAsync(compilerOptions)
+  const options = normalizeOptions(compilerOptions)
   const compiler = new NexeCompiler(options)
   const build = compiler.options.build
 

src/options.ts

@@ -1,9 +1,9 @@
 import * as parseArgv from 'minimist'
 import { NexeCompiler } from './compiler'
 import { isWindows, padRight } from './util'
-import { basename, extname, join, isAbsolute, relative, dirname } from 'path'
+import { basename, extname, join, isAbsolute, relative, dirname, resolve } from 'path'
 import { getTarget, NexeTarget } from './target'
-import { EOL } from 'os'
+import { EOL, homedir } from 'os'
 import * as c from 'chalk'
 
 export const version = '{{replace:0}}'
@@ -34,6 +34,7 @@ export interface NexeOptions {
   native: any
   empty: boolean
   sourceUrl?: string
+  enableStdIn?: boolean
   python?: string
   loglevel: 'info' | 'silent' | 'verbose'
   silent?: boolean
@@ -82,7 +83,7 @@ const alias = {
   l: 'loglevel',
   'fake-argv': 'fakeArgv'
 }
-const argv = parseArgv(process.argv, { alias, default: defaults })
+const argv = parseArgv(process.argv, { alias, default: { ...defaults, enableStdIn: true } })
 const g = c.gray
 let help = `
 ${c.bold('nexe <entry-file> [options]')}
@@ -112,7 +113,7 @@ ${c.bold('nexe <entry-file> [options]')}
    ${c.underline.bold('Other options:')}
 
        --bundle                     -- custom bundling module with 'createBundle' export
-       --temp                       -- temp file storage default './nexe'
+       --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
@@ -181,36 +182,38 @@ function extractName(options: NexeOptions) {
   return name.replace(/\.exe$/, '')
 }
 
-function isEntryFile(filename: string) {
-  return filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
+function isEntryFile(filename?: string): filename is string {
+  return Boolean(
+    filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
+  )
 }
 
-function findInput(input: string, cwd: string) {
-  const maybeInput = argv._.slice().pop() || ''
+export function resolveEntry(input: string, cwd: string, maybeEntry?: string) {
   if (input) {
-    return input
+    return resolve(cwd, input)
   }
-  if (isEntryFile(maybeInput)) {
-    return maybeInput
+  if (isEntryFile(maybeEntry)) {
+    return resolve(cwd, maybeEntry)
   }
   if (!process.stdin.isTTY) {
     return ''
   }
   try {
-    const main = require.resolve(cwd)
-    return './' + relative(cwd, main)
+    return require.resolve(cwd)
   } catch (e) {
-    void e
+    throw new Error('No entry file found')
   }
-  return ''
 }
 
-function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions> {
+function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
   const options = Object.assign({}, defaults, input) as NexeOptions
   const opts = options as any
-
-  options.temp = options.temp || process.env.NEXE_TEMP || join(options.cwd, '.nexe')
-  options.input = findInput(options.input, options.cwd)
+  const cwd = (options.cwd = resolve(options.cwd))
+  options.temp = options.temp
+    ? resolve(cwd, options.temp)
+    : process.env.NEXE_TEMP || join(homedir(), '.nexe')
+  const maybeEntry = input === argv ? argv._[argv._.length - 1] : undefined
+  options.input = resolveEntry(options.input, cwd, maybeEntry)
   options.name = extractName(options)
   options.loglevel = extractLogLevel(options)
   options.flags = flatten(opts.flag, options.flags)
@@ -219,6 +222,10 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
   options.configure = flatten(options.configure)
   options.resources = flatten(opts.resource, options.resources)
   options.rc = options.rc || extractCliMap(/^rc-.*/, options)
+  options.output = isWindows
+    ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
+    : `${options.output || options.name}`
+  options.output = resolve(cwd, options.output)
 
   if (!options.targets.length) {
     options.targets.push(getTarget())
@@ -240,14 +247,14 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
     return x
   }
 
-  options.plugins = options.plugins.map(requireDefault)
-  options.patches = options.patches.map(requireDefault)
+  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, help }
+export { argv, normalizeOptions, help }

src/steps/bundle.ts

@@ -16,17 +16,18 @@ function createBundle(options: NexeOptions) {
       })
     )
   }
+  const cwd = options.cwd
   const fuse = FuseBox.init({
     cache: false,
     log: Boolean(process.env.NEXE_BUNDLE_LOG) || false,
-    homeDir: options.cwd,
+    homeDir: cwd,
     sourceMaps: false,
     writeBundles: false,
     output: '$name.js',
     target: 'server',
     plugins
   })
-  const input = relative(options.cwd, options.input).replace(/\\/g, '/')
+  const input = relative(cwd, resolve(cwd, options.input)).replace(/\\/g, '/')
   fuse.bundle(options.name).instructions(`> ${input}`)
   return fuse.run().then((x: any) => {
     let output = ''
@@ -36,8 +37,9 @@ function createBundle(options: NexeOptions) {
 }
 
 export default async function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    compiler.input = await readFileAsync(compiler.options.input, 'utf-8')
+  const { bundle, cwd, empty, input } = compiler.options
+  if (!bundle) {
+    compiler.input = await readFileAsync(resolve(cwd, input), 'utf-8')
     return next()
   }
 
@@ -48,13 +50,13 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
 
   let producer = createBundle
   if (typeof compiler.options.bundle === 'string') {
-    producer = require(resolve(compiler.options.cwd, compiler.options.bundle)).createBundle
+    producer = require(resolve(cwd, bundle)).createBundle
   }
 
   compiler.input = await producer(compiler.options)
 
   if ('string' === typeof compiler.options.debugBundle) {
-    await writeFileAsync(compiler.options.debugBundle, compiler.input)
+    await writeFileAsync(resolve(cwd, compiler.options.debugBundle), compiler.input)
   }
 
   return next()

src/steps/cli.ts

@@ -1,19 +1,22 @@
-import { normalize } from 'path'
+import { normalize, relative } from 'path'
 import { Readable } from 'stream'
-import { createWriteStream, chmodSync } from 'fs'
+import { createWriteStream, chmodSync, statSync } from 'fs'
 import { readFileAsync, dequote, isWindows } from '../util'
 import { NexeCompiler } from '../compiler'
 import { NexeTarget } from '../target'
 
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
+function getStdIn(stdin: NodeJS.ReadStream): Promise<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()
+    let out = ''
+    stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        let current
+        while ((current = stdin.read())) {
+          out += current
+        }
+      })
+      .on('end', () => resolve(out))
   })
 }
 
@@ -34,9 +37,9 @@ function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
 export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
   const { log } = compiler
   let stdInUsed = false
-  if (!process.stdin.isTTY) {
+  if (!process.stdin.isTTY && compiler.options.enableStdIn) {
     stdInUsed = true
-    compiler.input = await readStreamAsync(process.stdin)
+    compiler.input = dequote(await getStdIn(process.stdin))
   }
 
   await next()
@@ -53,11 +56,15 @@ export default async function cli(compiler: NexeCompiler, next: () => Promise<vo
         if (e) {
           reject(e)
         } else if (compiler.output) {
-          chmodSync(compiler.output, '755')
+          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: '${stdInUsed
-              ? '[stdin]'
-              : compiler.options.input}' written to: ${compiler.output}`
+              ? compiler.options.empty ? '[empty]' : '[stdin]'
+              : inputFile}' written to: ${outputFile}`
           )
           resolve(compiler.quit())
         }

src/steps/shim-fs.ts

@@ -1,22 +1,73 @@
 import { Stats } from 'fs'
 import { ok } from 'assert'
-import { resolve, normalize } from 'path'
+import { dirname, resolve, normalize, basename } from 'path'
 
 const binary = (process as any).__nexe as NexeBinary
 ok(binary)
 const manifest = binary.resources
+const directories: { [key: string]: { [key: string]: boolean } } = {}
 const isString = (x: any): x is string => typeof x === 'string' || x instanceof String
+const isNotFile = () => false
+const isNotDirectory = isNotFile
+const isFile = () => true
+const isDirectory = isFile
 
 if (Object.keys(manifest).length) {
   const fs = require('fs')
   const originalReadFile = fs.readFile
   const originalReadFileSync = fs.readFileSync
+  const originalReaddir = fs.readdir
+  const originalReaddirSync = fs.readdirSync
+  const originalStatSync = fs.statSync
+  const originalStat = fs.stat
   const resourceStart = binary.layout.resourceStart
 
+  const statTime = function() {
+    const stat = binary.layout.stat
+    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(path: string | Buffer) {
+    const key = resolve(path)
+    if (directories[key]) {
+      return createStat({ isDirectory, isFile: isNotFile })
+    }
+    if (manifest[key]) {
+      return createStat(manifest[key], { isFile, isDirectory: isNotDirectory })
+    }
+  }
+
   let setupManifest = () => {
-    const manifest = binary.resources
     Object.keys(manifest).forEach(key => {
       const absolutePath = resolve(key)
+      const dirPath = dirname(absolutePath)
+      directories[dirPath] = directories[dirPath] || {}
+      directories[dirPath][basename(absolutePath)] = true
       if (!manifest[absolutePath]) {
         manifest[absolutePath] = manifest[key]
       }
@@ -27,8 +78,35 @@ if (Object.keys(manifest).length) {
     })
     setupManifest = () => {}
   }
-  //TODO track inflight fs reqs??
+  //naive patches intended to work for most use cases
   var nfs = {
+    readdir: function readdir(path: string | Buffer, options: any, callback: any) {
+      setupManifest()
+      path = path.toString()
+      if ('function' === typeof options) {
+        callback = options
+        options = { encoding: 'utf8' }
+      }
+      const dir = directories[resolve(path)]
+      if (dir) {
+        process.nextTick(() => {
+          callback(null, Object.keys(dir))
+        })
+      } else {
+        return originalReaddir.apply(fs, arguments)
+      }
+    },
+
+    readdirSync: function readdirSync(path: string | Buffer, options: any) {
+      setupManifest()
+      path = path.toString()
+      const dir = directories[resolve(path)]
+      if (dir) {
+        return Object.keys(dir)
+      }
+      return originalReaddirSync.apply(fs, arguments)
+    },
+
     readFile: function readFile(file: any, options: any, callback: any) {
       setupManifest()
       const entry = manifest[file]
@@ -75,6 +153,23 @@ if (Object.keys(manifest).length) {
       fs.readSync(fd, result, 0, length, resourceOffset)
       fs.closeSync(fd)
       return encoding ? result.toString(encoding) : result
+    },
+    statSync: function statSync(path: string | Buffer) {
+      const stat = ownStat(path)
+      if (stat) {
+        return stat
+      }
+      return originalStatSync.apply(fs, arguments)
+    },
+    stat: function stat(path: string | Buffer, callback: any) {
+      const stat = ownStat(path)
+      if (stat) {
+        process.nextTick(() => {
+          callback(null, stat)
+        })
+      } else {
+        return originalStat.apply(fs, arguments)
+      }
     }
   }
   Object.assign(fs, nfs)

src/steps/shim.ts

@@ -7,10 +7,22 @@ function wrap(code: string) {
 export default function(compiler: NexeCompiler, next: () => Promise<void>) {
   compiler.shims.push(wrap(compiler.getHeader()))
 
+  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
+    }
+  `)
+  )
+
   if (compiler.options.resources.length) {
     compiler.shims.push(wrap('{{replace:lib/steps/shim-fs.js}}'))
   }
 
+  //compiler.shims.push(wrap('{/{replace:lib/steps/shim-require.js}}'))
+
   if (compiler.options.fakeArgv) {
     const nty = !process.stdin.isTTY
     const input = nty ? '[stdin]' : compiler.options.input

src/target.ts

@@ -28,6 +28,7 @@ const prettyPlatform: { [key: string]: NodePlatform } = {
 //TODO arm
 const prettyArch: { [key: string]: NodeArch } = {
   x86: 'x86',
+  amd64: 'x64',
   ia32: 'x86',
   x32: 'x86',
   x64: 'x64'

tasks/asset-compile.ts

@@ -1,8 +1,5 @@
 import * as nexe from '../lib/nexe'
-import {
-  getUnBuiltReleases,
-  getLatestGitRelease
-} from '../lib/releases'
+import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
 import * as ci from './ci'
 import { runAlpineBuild } from './docker'
 import { getTarget } from '../lib/target'
@@ -15,11 +12,12 @@ const env = process.env,
   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)'
   }
 
@@ -32,7 +30,7 @@ if (require.main === module) {
   }
 }
 
-async function build () {
+async function build() {
   if (isScheduled) {
     const releases = await getUnBuiltReleases({ headers })
     if (!releases.length) {
@@ -54,8 +52,7 @@ 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,
@@ -63,16 +60,15 @@ async function build () {
         target,
         output
       }
-    
+
     const stop = keepalive()
     if (target.platform === 'alpine') {
-      await runAlpineBuild(target, nexe.version.split('.')[0])
+      await runAlpineBuild(target)
     } else {
-      await nexe.compile(options)      
+      await nexe.compile(options)
     }
     stop()
-    
-    
+
     if (await pathExistsAsync(output)) {
       await assertNexeBinary(output)
       const gitRelease = await getLatestGitRelease({ headers })
@@ -80,7 +76,7 @@ async function build () {
         query: { name: target.toString() },
         body: await readFileAsync(output),
         headers: {
-          'Authorization': 'token ' + env.GITHUB_TOKEN,
+          Authorization: 'token ' + env.GITHUB_TOKEN,
           'Content-Type': 'application/octet-stream',
           'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
         }
@@ -90,12 +86,12 @@ async function build () {
   }
 }
 
-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

@@ -5,8 +5,7 @@ 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}`
+  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: {
@@ -17,7 +16,7 @@ export function triggerMacBuild(release: NexeTarget, branch: string) {
   })
 }
 
-export function triggerDockerBuild (release: NexeTarget, branch: string) {
+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, {
@@ -38,15 +37,13 @@ export function triggerDockerBuild (release: NexeTarget, branch: string) {
     },
     headers: {
       'Travis-API-Version': '3',
-      'Authorization': `token ${env.TRAVIS_TOKEN}`
+      Authorization: `token ${env.TRAVIS_TOKEN}`
     }
   })
 }
 
-export function triggerWindowsBuild (release: NexeTarget) {
+export function triggerWindowsBuild(release: NexeTarget) {
   const hasVersion = 'NEXE_VERSION' in env
-  env.NEXE_VERSION = hasVersion 
-    ? env.NEXE_VERSION!.trim() 
-    : release.toString() 
+  env.NEXE_VERSION = hasVersion ? env.NEXE_VERSION!.trim() : release.toString()
   return Promise.resolve()
 }

tasks/docker.ts

@@ -5,7 +5,7 @@ import got = require('got')
 import execa = require('execa')
 import { appendFileSync } from 'fs'
 
-function alpine (target: NexeTarget, nexeVersion: string) {  
+function alpine(target: NexeTarget) {
   return `
 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
@@ -26,29 +26,34 @@ RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
 `.trim()
 }
 
-export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
-  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
+export async function runAlpineBuild(target: NexeTarget) {
+  await writeFileAsync('Dockerfile', alpine(target))
   const outFilename = 'nexe-alpine-build-log.txt'
   await writeFileAsync(outFilename, '')
   let output: any = []
 
   try {
-    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 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) {
+  } catch (e) {
     console.log('Error running docker', e)
   } 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))
+    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

@@ -10,21 +10,19 @@ 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[]) {
+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'))
-  })  
+    return replacements[+file] ? replacements[+file] : JSON.stringify(readFileSync(file, 'utf8'))
+  })
   writeFileSync(filename, contents)
   console.log(`Wrote: ${filename}`)
 }

test/fixture/package.json

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

test/mocha.opts

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

test/options.spec.ts

@@ -0,0 +1,48 @@
+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 pathed options against cwd', () => {
+      const cwd = '/a/b/c'
+      const options = normalizeOptions({ 
+        cwd, 
+        input: '123.js',
+        output: 'abc',
+        temp: './d' 
+      })
+      expect(options.temp).to.equal(path.resolve(cwd, './d'))
+      expect(options.input).to.equal(path.resolve(cwd, '123.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: 'src/folder/app.js'
+      })
+      expect(options.output).to.equal(path.resolve(`./app${ext}`))
+    }) 
+    it('should default to the folder/project name if filename is index', () => {
+      const options = normalizeOptions()
+      expect(options.output).to.equal(path.resolve(`./nexe${ext}`))
+    })
+  })
+})

test/target.spec.ts

@@ -10,7 +10,9 @@ 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`],

yarn.lock

@@ -90,6 +90,12 @@ acorn-jsx@^4.0.1:
   dependencies:
     acorn "^5.0.3"
 
+acorn-object-rest-spread@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/acorn-object-rest-spread/-/acorn-object-rest-spread-1.1.0.tgz#78699aefdd18ec3182caadadf52e2697c048f476"
+  dependencies:
+    acorn "^5.0.3"
+
 acorn@^2.6.4:
   version "2.7.0"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-2.7.0.tgz#ab6e7d9d886aaca8b085bc3312b79a198433f0e7"
@@ -993,14 +999,15 @@ fstream@^1.0.0, fstream@^1.0.10, fstream@^1.0.2:
     mkdirp ">=0.5 0"
     rimraf "2"
 
-fuse-box@2.2.31:
-  version "2.2.31"
-  resolved "https://registry.yarnpkg.com/fuse-box/-/fuse-box-2.2.31.tgz#36d267a6c6a79952a9c1fb7d1643c1949a6d42f5"
+fuse-box@^2.3.4-beta.5:
+  version "2.3.4-beta.5"
+  resolved "https://registry.yarnpkg.com/fuse-box/-/fuse-box-2.3.4-beta.5.tgz#531feff42d3fe7b4e0941f2196a3fe56ea402651"
   dependencies:
     acorn "^5.0.3"
     acorn-es7 "^0.1.0"
     acorn-es7-plugin "^1.1.7"
     acorn-jsx "^4.0.1"
+    acorn-object-rest-spread "^1.1.0"
     ansi "^0.3.1"
     app-root-path "^2.0.1"
     base64-img "^1.0.3"
@@ -1967,8 +1974,8 @@ preserve@^0.2.0:
   resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
 
 prettier@^1.6.1:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.7.0.tgz#47481588f41f7c90f63938feb202ac82554e7150"
+  version "1.7.4"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.7.4.tgz#5e8624ae9363c80f95ec644584ecdf55d74f93fa"
 
 pretty-time@^0.2.0:
   version "0.2.0"
@@ -2483,8 +2490,8 @@ type-is@~1.6.15:
     mime-types "~2.1.15"
 
 typescript@^2.4.1:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.5.2.tgz#038a95f7d9bbb420b1bf35ba31d4c5c1dd3ffe34"
+  version "2.5.3"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.5.3.tgz#df3dcdc38f3beb800d4bc322646b04a3f6ca7f0d"
 
 uglify-js@3.0.28:
   version "3.0.28"