fix: cache for build vs target

.travis.yml

@@ -1,7 +1,9 @@
+os: osx
 language: node_js
 node_js:
 - '6'
 script: npm run nexe-build
 env:
-  global:
-    secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
+  - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
+notifications:
+  email: false

.vscode/settings.json

@@ -3,6 +3,7 @@
   "prettier.semi": false,
   "prettier.singleQuote": true,
   "prettier.typescriptEnable": ["typescript"],
+  "editor.trimAutoWhitespace": true,
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,

circle.yml

@@ -1,3 +1,8 @@
+machine:
+  node:
+    version: 6.11.2
+  services:
+    - docker
 test:
   override:
     - npm run nexe-build

examples/native-build/package.json

@@ -13,6 +13,6 @@
     "zmq": "^2.15.3"
   },
   "devDependencies": {
-    "fuse-box": "^2.2.1-beta.7"
+    "fuse-box": "^2.2.31"
   }
 }

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.1",
+  "version": "2.0.0-rc.4",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
@@ -11,7 +11,8 @@
   "scripts": {
     "nexe-build": "ts-node tasks/build",
     "prebuild": "rimraf lib && npm run lint",
-    "prepublish": "npm run build",
+    "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"
   },
@@ -34,7 +35,7 @@
     "app-builder": "^5.1.0",
     "chalk": "^1.1.3",
     "download": "^6.2.0",
-    "fuse-box": "^2.2.1",
+    "fuse-box": "2.2.31",
     "globby": "^6.1.0",
     "minimist": "^1.2.0",
     "mkdirp": "^0.5.1",
@@ -45,17 +46,18 @@
   },
   "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",
+    "@types/mocha": "^2.2.42",
     "@types/ora": "^0.3.31",
     "@types/pify": "0.0.28",
     "@types/rimraf": "0.0.28",
-    "execa": "0.8.0",
+    "chai": "^4.1.2",
     "got": "^7.1.0",
-    "mocha": "^3.2.0",
+    "mocha": "^3.5.0",
     "prettier": "^1.6.1",
     "ts-node": "3.3.0",
     "typescript": "^2.4.1"

src/compiler.ts

@@ -8,7 +8,9 @@ import { Logger } from './logger'
 import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
 import { NexeOptions, nexeVersion } from './options'
 import { NexeTarget } from './target'
-import { getLatestGitRelease, storeAsset } from './releases'
+import download = require('download')
+import { getLatestGitRelease } from './releases'
+import { IncomingMessage } from 'http'
 
 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
@@ -35,7 +37,7 @@ export class NexeCompiler {
   public input: string
   public bundledInput?: string
   public output: string | null
-
+  public targets: NexeTarget[]
   public resources: { bundle: string; index: { [key: string]: number[] } } = {
     index: {},
     bundle: ''
@@ -51,6 +53,7 @@ export class NexeCompiler {
 
   constructor(public options: NexeOptions) {
     const { python } = (this.options = options)
+    this.targets = options.targets as NexeTarget[]
     this.log.step('nexe ' + nexeVersion, 'info')
     if (python) {
       if (isWindows) {
@@ -93,7 +96,7 @@ export class NexeCompiler {
     return this.log.flush()
   }
 
-  private _getNodeExecutableLocation(target?: NexeTarget) {
+  public getNodeExecutableLocation(target?: NexeTarget) {
     if (target) {
       return join(this.options.temp, target.toString())
     }
@@ -131,19 +134,35 @@ export class NexeCompiler {
       `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
     )
     await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this._getNodeExecutableLocation())
+    return createReadStream(this.getNodeExecutableLocation())
   }
 
   private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    const githubRelease = await getLatestGitRelease()
+    const downloadOptions: any = {
+      headers: {
+        'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
+      }
+    }
+    const githubRelease = await getLatestGitRelease(downloadOptions)
     const assetName = target.toString()
     const asset = githubRelease.assets.find(x => x.name === assetName)
 
     if (!asset) {
-      throw new Error(`${assetName} not available, create one using --build`)
+      throw new Error(`${assetName} not available, create it using the --build flag`)
     }
-    const filename = this._getNodeExecutableLocation(target)
-    await storeAsset(asset, dirname(filename))
+    const filename = this.getNodeExecutableLocation(target)
+    await download(
+      asset.browser_download_url,
+      dirname(filename),
+      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)
   }
 
@@ -172,14 +191,13 @@ export class NexeCompiler {
   async compileAsync(target: NexeTarget) {
     const step = (this.compileStep = this.log.step('Compiling result'))
     const build = this.options.build
-    const location = this._getNodeExecutableLocation(target)
+    const location = this.getNodeExecutableLocation(build ? undefined : target)
     let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
     const header = this._generateHeader()
-
-    if (target && !build) {
+    if (!build && !binary) {
+      step.modify('Fetching prebuilt binary')
       binary = await this._fetchPrebuiltBinaryAsync(target)
     }
-
     if (!binary) {
       binary = await this._buildAsync()
       step.log('Node binary compiled')

src/nexe.ts

@@ -9,11 +9,12 @@ import {
   NexePatch
 } from './options'
 import cli from './steps/cli'
-import bundle from './bundling/fuse'
+import bundle from './steps/bundle'
 import download from './steps/download'
 import artifacts from './steps/artifacts'
 import patches from './patches'
 import { rimrafAsync } from './util'
+import { NexeTarget } from './target'
 
 async function compile(
   compilerOptions?: Partial<NexeOptions>,
@@ -24,10 +25,14 @@ async function compile(
   const build = compiler.options.build
 
   if (options.clean) {
+    let path = compiler.src
+    if (!options.build) {
+      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
+    }
     const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting directory and contents at: ${compiler.src}`)
-    await rimrafAsync(compiler.src)
-    step.log(`Deleted directory and contents at: ${compiler.src}`)
+    step.log(`Deleting contents at: ${path}`)
+    await rimrafAsync(path)
+    step.log(`Deleted contents at: ${path}`)
     return compiler.quit()
   }
 

src/options.ts

@@ -1,11 +1,12 @@
 import * as parseArgv from 'minimist'
 import { NexeCompiler } from './compiler'
-import { isWindows } from './util'
+import { isWindows, padRight } from './util'
 import { basename, extname, join, isAbsolute, relative } from 'path'
 import { getTarget, NexeTarget } from './target'
 import { EOL } from 'os'
+import * as chalk from 'chalk'
 
-export const nexeVersion = '2.0.0-rc.1'
+export const nexeVersion = '2.0.0-rc.4'
 
 export interface NexePatch {
   (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -38,6 +39,7 @@ export interface NexeOptions {
   verbose?: boolean
   info?: boolean
   ico?: string
+  debugBundle?: boolean
   warmup?: string
   compress?: boolean
   clean?: boolean
@@ -47,10 +49,6 @@ export interface NexeOptions {
   downloadOptions: any
 }
 
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-
 const defaults = {
   version: process.version.slice(1),
   flags: [],
@@ -82,24 +80,25 @@ const alias = {
   l: 'loglevel'
 }
 const argv = parseArgv(process.argv, { alias, default: defaults })
+const g = chalk.gray
 const help =
   `
 nexe --help              CLI 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
-  -i   --input      =index.js               -- application entry point
-  -o   --output     =my-app.exe             -- path to output file
-  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
-  -n   --name       =my-app                 -- main app module name
-  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
-  -p   --python     =/path/to/python2       -- python executable
-  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
-  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure step
-  -m   --make       ="--loglevel"           -- *pass arguments to the make/build step
-  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
-  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
-       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
-       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
+       --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)
@@ -171,13 +170,15 @@ function findInput(input: string, cwd: string) {
   if (isEntryFile(maybeInput)) {
     return maybeInput
   }
+  if (!process.stdin.isTTY) {
+    return ''
+  }
   try {
     const main = require.resolve(cwd)
     return './' + relative(cwd, main)
   } catch (e) {
     void e
   }
-
   return ''
 }
 
@@ -195,26 +196,26 @@ function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOption
   options.input = findInput(options.input, options.cwd)
   options.loglevel = extractLogLevel(options)
   options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets)
+  options.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.rc = options.rc || extractCliMap(/^rc-.*/, options)
 
-  options.targets = options.targets.map(getTarget)
+  if (!options.targets.length) {
+    options.targets = [getTarget(options.version)]
+  }
 
-  if (options.build && options.targets.length) {
+  if (options.build) {
     const { arch } = options.targets[0] as NexeTarget
     if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat([arch])))
+      options.make = Array.from(new Set(options.make.concat(arch)))
     } else {
       options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
     }
   }
 
-  if (!options.targets.length) {
-    options.targets = [getTarget(options.version)]
-  }
+  options.version = (options.targets[0] as NexeTarget).version
 
   options.patches = options.patches.map(x => {
     if (typeof x === 'string') {

src/releases.ts

@@ -42,11 +42,6 @@ export function getLatestGitRelease(options?: any) {
   return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
 }
 
-export async function storeAsset(asset: GitAsset, dest: string, headers?: any) {
-  const options = headers ? { headers } : undefined
-  await download(asset.browser_download_url, dest, options as any)
-}
-
 export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
     'https://nodejs.org/download/release/index.json'

src/steps/bundle.ts

@@ -1,6 +1,6 @@
 import { NexeCompiler } from '../compiler'
 import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
-import { readFileAsync } from '../util'
+import { readFileAsync, writeFileAsync } from '../util'
 //import NativeModulePlugin from './fuse-native-module-plugin'
 
 function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
@@ -53,5 +53,10 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
     name: compiler.options.name,
     minify: compiler.options.compress
   })
+
+  if (compiler.options.debugBundle) {
+    await writeFileAsync(compiler.options.debugBundle, compiler.input)
+  }
+
   return next()
 }

src/steps/download.ts

@@ -3,6 +3,7 @@ import { pathExistsAsync } from '../util'
 import { LogStep } from '../logger'
 import { IncomingMessage } from 'http'
 import { NexeCompiler } from '../compiler'
+import { NexeTarget } from '../target'
 
 function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
   const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
@@ -27,8 +28,8 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
  * @param {*} next
  */
 export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src, log } = compiler
-  const { version, sourceUrl, downloadOptions } = compiler.options
+  const { src, log, targets: [{ version }] } = compiler
+  const { sourceUrl, downloadOptions } = compiler.options
   const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
   const step = log.step(`Downloading Node.js source from: ${url}`)
   if (await pathExistsAsync(src)) {

src/target.ts

@@ -8,14 +8,15 @@ export { platforms, architectures }
 
 export interface NexeTarget {
   version: string
-  platform: NodePlatform
-  arch: NodeArch
+  platform: NodePlatform | string
+  arch: NodeArch | string
 }
 
 //TODO bsd
 const prettyPlatform: { [key: string]: NodePlatform } = {
   win32: 'windows',
   windows: 'windows',
+  win: 'windows',
   darwin: 'mac',
   macos: 'mac',
   mac: 'mac',
@@ -36,7 +37,7 @@ function isVersion(x: string) {
   if (!x) {
     return false
   }
-  return /\d/.test(x.replace(/v|\./g, ''))
+  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
 }
 
 function isPlatform(x: string): x is NodePlatform {
@@ -61,7 +62,7 @@ export function targetsEqual(a: NexeTarget, b: NexeTarget) {
   return a.arch === b.arch && a.platform === b.platform && a.version === b.version
 }
 
-export function getTarget(target: string | NexeTarget = ''): NexeTarget {
+export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
   let arch = process.arch as NodeArch,
     platform = prettyPlatform[process.platform],
     version = process.version.slice(1)
@@ -75,7 +76,7 @@ export function getTarget(target: string | NexeTarget = ''): NexeTarget {
     .split('-')
     .forEach(x => {
       if (isVersion(x)) {
-        version = x
+        version = x.replace(/v/g, '')
       }
       if (isPlatform(x)) {
         platform = prettyPlatform[x]

src/util.ts

@@ -22,6 +22,10 @@ function falseOnEnoent(e: any) {
   throw e
 }
 
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).substr(0, l)
+}
+
 function dequote(input: string) {
   input = input.trim()
   const singleQuote = input.startsWith("'") && input.endsWith("'")
@@ -57,6 +61,7 @@ function isDirectoryAsync(path: string) {
 
 export {
   dequote,
+  padRight,
   isWindows,
   rimrafAsync,
   statAsync,

tasks/build.ts

@@ -12,13 +12,16 @@ import got = require('got')
 const env = process.env,
   branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
   isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isLinux = Boolean(env.TRAVIS),
+  isLinux = Boolean(env.CIRCLECI),
   isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.CIRCLECI),
+  isMac = Boolean(env.TRAVIS),
   isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
     || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
     || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = { 'Authorization': 'token ' + env.GITHUB_TOKEN }
+  headers = { 
+    'Authorization': 'token ' + env.GITHUB_TOKEN,
+    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
+  }
 
 if (require.main === module) {
   if (!isPullRequest) {
@@ -57,7 +60,7 @@ async function build () {
       options = {
         empty: true,
         build: true,
-        target, //FIXME
+        target,
         output
       }
     
@@ -78,7 +81,8 @@ async function build () {
         body: await readFileAsync(output),
         headers: {
           'Authorization': 'token ' + env.GITHUB_TOKEN,
-          'Content-Type': 'application/octet-stream'
+          'Content-Type': 'application/octet-stream',
+          'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
         }
       })
       console.log(target + ' uploaded.')

tasks/ci.ts

@@ -3,7 +3,7 @@ import got = require('got')
 import * as assert from 'assert'
 const { env } = process
 
-export function triggerDockerBuild(release: NexeTarget, branch: string) {
+export function triggerMacBuild(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 +14,7 @@ export function triggerDockerBuild(release: NexeTarget, branch: string) {
         config: {
           merge_mode: 'deep_merge',
           env: {
-            NEXE_VERSION: release
+            NEXE_VERSION: release.toString()
           }
         }
       }
@@ -26,7 +26,7 @@ export function triggerDockerBuild(release: NexeTarget, branch: string) {
   })
 }
 
-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, {

tasks/docker.ts

@@ -1,32 +1,73 @@
 import { NexeTarget } from '../src/target'
-import { writeFileAsync } from '../src/util'
-import exec = require('execa')
+import { writeFileAsync, readFileAsync } from '../src/util'
+import { spawn } from 'child_process'
+import got = require('got')
+import { createWriteStream, WriteStream } from 'fs'
 
-function alpine (target: NexeTarget, nexeVersion: string) {
-  const version = target.version
+function alpine (target: NexeTarget, nexeVersion: string) {  
   return `
-FROM i386/alpine:3.6
+FROM i386/alpine:3.4
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
+ENV NODE_VERSION=${target.version}
+ENV NEXE_VERSION=beta
 WORKDIR /
-RUN curl -sSL https://nodejs.org/dist/v${version}/node-v${version}.tar.gz | tar -xz && \
-  cd /node-v${version} && \
+
+RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
+  cd /node-v\${NODE_VERSION} && \
   ./configure --prefix=/usr --fully-static && \
-  make -j$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
+  make -j$(getconf _NPROCESSORS_ONLN) && \
   make install && \
   paxctl -cm /usr/bin/node
 
-RUN mkdir nexe_temp && mv node-v${version} nexe_temp/${version}
-RUN npm i nexe@beta -g
-ENV NEXE_TEMP=/nexe_temp
+RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+  npm install -g nexe@\${NEXE_VERSION} && \
+  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out
+`.trim()
+}
 
-RUN nexe --empty -c="--fully-static" -o /nexe-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 option = { stido: 'inherit' } as any
-  await exec('docker', ['build', '-t', 'nexe-alpine', '.'], option)
-  await exec('docker', ['run', '--name', 'nexe', 'nexe-alpine'], option)
-  await exec('docker', ['cp', 'nexe:/nexe-out', 'out'], option)
-  await exec('docker', ['rm', 'nexe'], option)
+  const outFilename = 'nexe-alpine-build-log.txt'
+  const output = createWriteStream(outFilename)
+  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)
+  } catch(e) {
+    console.log(e)
+  } finally {
+    output.close()
+    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
+      body: await readFileAsync(outFilename),
+      method: 'PUT'
+    })
+    .then(x => console.log(x.body))
+    .catch(e => console.log('Error posting log', e))
+  }
 }

test/mocha.opts

@@ -0,0 +1,3 @@
+--check-leaks
+--require ts-node/register
+--recursive

test/target.spec.ts

@@ -0,0 +1,28 @@
+import { padRight, isWindows } from '../src/util'
+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
+
+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'],
+    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
+    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
+    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
+    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
+    ['not-a-thing', getTarget(process).toString()]
+  ].forEach(([input, expected]) => {
+    it(`${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
+      expect(getTarget(input).toString()).to.equal(expected)
+    })
+  })
+
+  it ('should stringify and toString', () => {
+    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
+  })
+})
+