feat: add asset flag for using cached artifact

closes #645

.circleci/build.sh

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

.circleci/config.yml

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

.circleci/setup.sh

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

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: https://www.paypal.me/calebsboyd

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,23 @@
+---
+name: Bug Report
+about: Report a bug encountered while running Nexe
+labels: bug
+
+---
+<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!
+-->
+
+**What happened**:
+
+**What you expected to happen**:
+
+**How to reproduce it (as minimally and precisely as possible)**:
+
+**Anything else we need to know?**:
+
+**Environment**:
+- Platform(OS/Version):
+- Host Node Version:
+- Target Node Version:
+- Nexe version:
+- Python Version:

.github/ISSUE_TEMPLATE/feature.md

@@ -0,0 +1,11 @@
+---
+name: Feature Request
+about: Suggest an feature request
+labels: feature
+
+---
+<!-- Please only use this template for submitting feature requests -->
+
+**What would you like to be added**:
+
+**Why is this needed**:

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,11 @@
+**What this PR does / why we need it**:
+
+**Which issue(s) this PR fixes**:
+<!--
+*Automatically closes linked issue when PR is merged.
+Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
+_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
+-->
+Fixes #
+
+**Special notes for your reviewer**:

.gitignore

@@ -1,6 +1,7 @@
 .DS_Store
 temp/
 coverage
+nexe
 node_modules
 *.log
 *.exe

.travis.yml

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

.vscode/extensions.json

@@ -1,3 +1,3 @@
 {
-    "recommendations": [ "eg2.tslint" ]
+    "recommendations": [ "ms-vscode.vscode-typescript-tslint-plugin" ]
 }

README.md

@@ -1,9 +1,7 @@
 <p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>
 
 <p align="center">
-  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/github/nexe/nexe/master.svg" alt="Mac Build Status"></a>
-  <a href="https://travis-ci.org/nexe/nexe/builds"><img src="https://img.shields.io/travis/nexe/nexe/master.svg" alt="Linux Build Status"></a>
-  <a href="https://ci.appveyor.com/project/calebboyd/nexe/history"><img src="https://img.shields.io/appveyor/ci/calebboyd/nexe/master.svg" alt="Windows Build Status"></a>
+  <a href="https://dev.azure.com/nexe-ci/Nexe/_build?definitionId=1"><img src="https://img.shields.io/azure-devops/build/nexe-ci/nexe/1/master.svg" alt="Build Status"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/dt/nexe.svg" alt="Downloads"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/v/nexe.svg" alt="Version"></a>
   <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/l/nexe.svg" alt="License"></a>
@@ -51,8 +49,7 @@ Additional files or resources can be added to the binary by passing `-r "glob/pa
 
 ## Compiling Node
 
-By default `nexe` will attempt to download a pre-built executable. However, It may be unavailable ([github releases](https://github.com/nexe/nexe/releases))
-or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 2. eg. Systems that have python2 will need to create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486).
+By default `nexe` will attempt to download a pre-built executable. These are listed on the [Nexe V3 releases page](https://github.com/nexe/nexe/releases/tag/v3.3.3). The exact version you want may be unavailable or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 2. eg. Systems that have python2 will need to create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486).
 
 ## Node.js API
 
@@ -113,8 +110,15 @@ compile({
  - #### `cwd: string`
     - Directory nexe will operate on as though it is the cwd
     - default: process.cwd()
+ - #### `mangle: boolean`
+    - If set to false, nexe will not include the virtual filesystem (your application and resources) on the output.
+    - This will cause the output to error as an "Invalid Binary" unless a userland patch alters the contents of lib/_third_party_main.js in the nodejs source.
+    - default: true
  - #### `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)
+ - #### `remote: string`
+    - Provide a custom remote location for fetching pre-built nexe binaries from. This can either be an HTTP or HTTPS URL or a file path.
+    - default: `null`
  - #### `python: string`
     - On Linux this is the path pointing to your python2 executable
     - On Windows this is the directory where `python` can be accessed
@@ -148,7 +152,7 @@ compile({
     - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
  - #### `rc: object`
     - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example (keys may vary depending ont the version. Reference the file linked above):
+    - Example (keys may vary depending on the version. Reference the file linked above):
       ```javascript
         {
           CompanyName: "ACME Corp",
@@ -166,7 +170,7 @@ compile({
       variable will still be processed. NODE_OPTIONS support can be disabled with the `--without-node-options` configure flag.
     - default: `false`
   - #### `fakeArgv: boolean`
-    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`. 
+    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`.
  - #### `ghToken: string`
     - Provide a Github Token for accessing nexe releases
     - This is usually needed in CI environments
@@ -198,7 +202,7 @@ 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.
- - `addResource(filename: string, contents: Buffer): void`
+ - `addResource(filename: string, contents: Buffer): Promise<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.
@@ -212,9 +216,7 @@ Any modifications made to `NexeFile#contents` will be maintained in the cache _w
 
 ## Native Modules
 
-TODO
-
-- [ ] Implement support for `node-pre-gyp#find`.
+In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.
 
 ## Contributing
 
@@ -222,20 +224,10 @@ Building
 ```
 $ git clone git@github.com:nexe/nexe.git
 $ cd nexe
-$ yarn
+$ npm i && npm run build
 ```
 
 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) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
----|---|---|
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) |  [Dustin Greif](https://github.com/dgreif) |
-
-### Former
-
-- [Craig Condon](http://crcn.codes/)

appveyor.yml

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

azure-pipelines.yml

@@ -0,0 +1,69 @@
+schedules:
+- cron: "0 8 * * *"
+  displayName: "Daily Build 1"
+  always: true
+  branches:
+    include:
+      - master
+- cron: "0 13 * * *"
+  displayName: "Daily Build 2"
+  always: true
+  branches:
+    include:
+      - master
+- cron: "0 19 * * *"
+  displayName: "Daily Build 3"
+  always: true
+  branches:
+    include:
+      - master
+jobs:
+- job: BaseBuild
+  timeoutInMinutes: 360
+  strategy:
+    matrix:
+      linux:
+        imageName: 'ubuntu-16.04'
+      mac:
+        imageName: 'macos-10.15'
+      windows_2017:
+        imageName: 'vs2017-win2016'
+      windows_2015:
+        imageName: 'vs2017-win2016'
+      alpine:
+        imageName: 'ubuntu-16.04'
+  pool:
+    vmImage: $(imageName)
+  steps:
+  - task: UsePythonVersion@0
+    displayName: Setup Python
+    inputs:
+      versionSpec: '2.7'
+      architecture: 'x64'
+  - task: NodeTool@0
+    displayName: Install Node
+    inputs:
+      versionSpec: '12.x'
+  - script: sudo apt-get update && sudo apt-get install -y libc6-dev-i386 gcc-multilib g++-multilib
+    condition: contains(variables['Agent.JobName'], 'linux')
+    displayName: Install Linux build dependencies
+  - script: choco install visualcpp-build-tools --version 14.0.25420.1 -fy && npm config set msvs_version 2015
+    condition: contains(variables['Agent.JobName'], 'windows_2015')
+    displayName: Install Windows build dependencies
+  - script: npm install && npm run ci:build
+    displayName: Build Nexe
+    env:
+      GITHUB_TOKEN: $(PersonalGithubToken)
+      NEXE_VERBOSE: $(NEXE_VERBOSE)
+      msbuild_args: /3G
+    condition: not(contains(variables['Agent.JobName'], 'windows'))
+  - powershell: |
+      iex (new-object net.webclient).downloadstring('https://get.scoop.sh')
+      scoop install nasm
+      npm install
+      npm run ci:build
+    displayName: Build Nexe (Windows)
+    condition: contains(variables['Agent.JobName'], 'windows')
+    env:
+      GITHUB_TOKEN: $(PersonalGithubToken)
+      NEXE_VERBOSE: $(NEXE_VERBOSE)

issue_template.md

@@ -1,19 +0,0 @@
-<!-- If you need help or think you have found a bug, please help us with your issue by entering the following information (otherwise you can delete this text): -->
-
-**Is this a BUG or a FEATURE REQUEST?:** 
-
-**What happened:**
-
-**What you expected to happen:**
-
-**How to reproduce it (as minimally and precisely as possible):**
-
-**Anything else we need to know?:**
-
-**Environment**
-
-- Platform(OS/Version):
-- Host Node Version:
-- Target Node Version:
-- Nexe version:
-- Python Version:

package.json

@@ -2,14 +2,14 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "3.0.0",
+  "version": "4.0.0-beta.17",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
     "Caleb Boyd <caleb.boyd@hotmail.com>"
   ],
   "scripts": {
-    "asset-compile": "ts-node tasks/asset-compile",
+    "ci:build": "ts-node tasks/build",
     "test": "mocha",
     "lint": "tslint \"{src,plugins,tasks}/**/*.ts\" --fix",
     "prepare": "npm run lint && npm run build && npm test",
@@ -30,47 +30,46 @@
     "nexe": "index.js"
   },
   "engines": {
-    "node": ">=6"
+    "node": ">=10"
   },
   "dependencies": {
     "@calebboyd/semaphore": "^1.3.1",
-    "app-builder": "^5.2.0",
+    "app-builder": "^6.2.2",
     "caw": "^2.0.1",
     "chalk": "^2.4.2",
     "cherow": "1.6.9",
-    "download": "^7.1.0",
-    "globby": "^9.1.0",
-    "got": "^9.6.0",
-    "minimist": "^1.2.0",
-    "mkdirp": "^0.5.1",
-    "multistream": "^2.1.1",
-    "ora": "^3.2.0",
-    "pify": "^4.0.1",
-    "resolve-dependencies": "^2.2.2",
-    "rimraf": "^2.6.3"
+    "download": "^8.0.0",
+    "globby": "^11.0.1",
+    "got": "^11.8.1",
+    "minimist": "^1.2.5",
+    "mkdirp": "^1.0.4",
+    "multistream": "^4.0.1",
+    "ora": "^3.4.0",
+    "pify": "^5.0.0",
+    "resolve-dependencies": "^6.0.4",
+    "rimraf": "^3.0.2"
   },
   "devDependencies": {
-    "@types/chai": "^4.1.7",
-    "@types/download": "^6.2.4",
-    "@types/execa": "^0.9.0",
-    "@types/globby": "^9.1.0",
-    "@types/got": "^9.4.1",
-    "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^0.5.2",
-    "@types/mocha": "^5.2.6",
+    "@types/chai": "^4",
+    "@types/download": "^6",
+    "@types/globby": "^9",
+    "@types/got": "^9.6.11",
+    "@types/minimist": "^1.2.1",
+    "@types/mkdirp": "^1.0.1",
+    "@types/mocha": "^7",
     "@types/multistream": "^2.1.1",
     "@types/ora": "^3.2.0",
-    "@types/pify": "3.0.2",
-    "@types/rimraf": "2.0.2",
-    "@types/semver": "^5.5.0",
+    "@types/pify": "5.0.0",
+    "@types/rimraf": "3.0.0",
+    "@types/semver": "^7.3.4",
     "chai": "^4.2.0",
-    "execa": "^1.0.0",
-    "mocha": "^6.0.2",
-    "prettier": "^1.16.4",
-    "ts-node": "^8.0.3",
-    "tslint": "^5.14.0",
+    "execa": "^5.0.0",
+    "mocha": "^7",
+    "prettier": "^2.2.1",
+    "ts-node": "^8.9.0",
+    "tslint": "^6.1.1",
     "tslint-config-prettier": "^1.18.0",
-    "tslint-plugin-prettier": "^2.0.1",
-    "typescript": "^3.4.1"
+    "tslint-plugin-prettier": "^2.3.0",
+    "typescript": "^3.8.3"
   }
 }

src/compiler.ts

@@ -1,4 +1,4 @@
-import { delimiter, dirname, normalize, join } from 'path'
+import { delimiter, resolve, normalize, join } from 'path'
 import { Buffer } from 'buffer'
 import { createReadStream, ReadStream } from 'fs'
 import { spawn } from 'child_process'
@@ -11,15 +11,14 @@ import {
   dequote,
   isWindows,
   bound,
-  semverGt
+  semverGt,
+  wrap,
 } from './util'
 import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
-import download = require('download')
-import { getLatestGitRelease } from './releases'
-import { IncomingMessage } from 'http'
-import combineStreams = require('multistream')
+import MultiStream = require('multistream')
 import { Bundle, toStream } from './fs/bundle'
+import { File } from 'resolve-dependencies'
 
 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
@@ -30,7 +29,7 @@ type StringReplacer = (match: string) => string
 export interface NexeFile {
   filename: string
   absPath: string
-  contents: string
+  contents: string | Buffer
 }
 
 export { NexeOptions }
@@ -101,11 +100,22 @@ export class NexeCompiler {
    * The file path of node binary
    */
   public nodeSrcBinPath: string
+  /**
+   * Remote asset path if available
+   */
+  public remoteAsset: string
 
   constructor(public options: NexeOptions) {
     const { python } = (this.options = options)
+    //SOMEDAY iterate over multiple targets with `--outDir`
     this.targets = options.targets as NexeTarget[]
     this.target = this.targets[0]
+    if (!/https?\:\/\//.test(options.remote)) {
+      throw new NexeError(
+        `Invalid remote URI scheme (must be http, https, or file): ${options.remote}`
+      )
+    }
+    this.remoteAsset = options.remote + this.target.toString()
     this.src = join(this.options.temp, this.target.version)
     this.configureScript = configure + (semverGt(this.target.version, '10.10.0') ? '.py' : '')
     this.nodeSrcBinPath = isWindows
@@ -128,31 +138,23 @@ export class NexeCompiler {
   }
 
   @bound
-  addResource(file: string, content?: Buffer | string) {
-    return this.bundle.addResource(file, content)
-  }
-
-  get binaryConfiguration() {
-    return { resources: this.bundle.index }
-  }
-
-  get resourceSize() {
-    return this.bundle.blobSize
+  addResource(absoluteFileName: string, content?: Buffer | string | File) {
+    return this.bundle.addResource(absoluteFileName, content)
   }
 
   @bound
   async readFileAsync(file: string) {
     this.assertBuild()
-    let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+    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 => {
+        contents: await readFileAsync(absPath, 'utf-8').catch((x) => {
           if (x.code === 'ENOENT') return ''
           throw x
-        })
+        }),
       }
       this.files.push(cachedFile)
     }
@@ -168,11 +170,11 @@ export class NexeCompiler {
   @bound
   async replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer) {
     const entry = await this.readFileAsync(file)
-    entry.contents = entry.contents.replace(replace, value as any)
+    entry.contents = entry.contents.toString().replace(replace, value as any)
   }
 
   @bound
-  async setFileContentsAsync(file: string, contents: string) {
+  async setFileContentsAsync(file: string, contents: string | Buffer) {
     const entry = await this.readFileAsync(file)
     entry.contents = contents
   }
@@ -190,6 +192,9 @@ export class NexeCompiler {
   }
 
   public getNodeExecutableLocation(target?: NexeTarget) {
+    if (this.options.asset) {
+      return resolve(this.options.cwd, this.options.asset)
+    }
     if (target) {
       return join(this.options.temp, target.toString())
     }
@@ -204,7 +209,7 @@ export class NexeCompiler {
       spawn(command, args, {
         cwd: this.src,
         env: this.env,
-        stdio: this.log.verbose ? 'inherit' : 'ignore'
+        stdio: this.log.verbose ? 'inherit' : 'ignore',
       })
         .once('error', (e: Error) => {
           if (this.log.verbose) {
@@ -226,9 +231,12 @@ export class NexeCompiler {
   }
 
   private _configureAsync() {
+    if (isWindows && semverGt(this.target.version, '10.15.99')) {
+      return Promise.resolve()
+    }
     return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
       this.configureScript,
-      ...this.options.configure
+      ...this.options.configure,
     ])
   }
 
@@ -247,11 +255,8 @@ export class NexeCompiler {
     return createReadStream(this.getNodeExecutableLocation())
   }
 
-  private async _shouldCompileBinaryAsync(
-    binary: NodeJS.ReadableStream | null,
-    location: string | undefined
-  ) {
-    //TODO combine make/configure/vcBuild/and modified times of included files
+  private async _shouldCompileBinaryAsync(binary: NodeJS.ReadableStream | null, location: string) {
+    //SOMEDAY combine make/configure/vcBuild/and modified times of included files
     const { snapshot, build } = this.options
 
     if (!binary) {
@@ -261,8 +266,6 @@ export class NexeCompiler {
     if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
       const snapshotLastModified = (await statAsync(snapshot)).mtimeMs
       const binaryLastModified = (await statAsync(location)).mtimeMs
-      // if build was requested and there's a snapshot to embed in the binary,
-      // we need to rebuild if the snapshot was just modified.
       return snapshotLastModified > binaryLastModified
     }
 
@@ -286,22 +289,24 @@ export class NexeCompiler {
     return [this.shims.join(''), this.startup].join(';')
   }
 
-  private _assembleDeliverable(binary: NodeJS.ReadableStream) {
+  private async _assembleDeliverable(binary: NodeJS.ReadableStream) {
     if (!this.options.mangle) {
       return binary
     }
+    const resources = this.bundle.renderIndex()
+    this.shims.unshift(wrap(`process.__nexe = ${JSON.stringify({ resources })};\n`))
 
-    const startup = this.code(),
-      codeSize = Buffer.byteLength(startup)
+    const code = this.code(),
+      codeSize = Buffer.byteLength(code),
+      lengths = Buffer.from(Array(16))
 
-    const lengths = Buffer.from(Array(16))
     lengths.writeDoubleLE(codeSize, 0)
-    lengths.writeDoubleLE(this.bundle.blobSize, 8)
-    return combineStreams([
+    lengths.writeDoubleLE(this.bundle.size, 8)
+    return new (MultiStream as any)([
       binary,
-      toStream(startup),
+      toStream(code),
       this.bundle.toStream(),
-      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
+      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
     ])
   }
 }

src/fs/bundle.ts

@@ -1,70 +1,156 @@
-import { stat as getStat, Stats, createReadStream } from 'fs'
+import * as fs from 'fs'
+import { promisify } from 'util'
 import { relative } from 'path'
 import { Readable } from 'stream'
-import combineStreams = require('multistream')
+import { argv } from '../options'
+import { File } from 'resolve-dependencies'
+import MultiStream = require('multistream')
 
-const stat = (file: string): Promise<Stats> => {
-  return new Promise((resolve, reject) => {
-    getStat(file, (err, stats) => (err ? reject(err) : resolve(stats)))
-  })
-}
+const lstat = promisify(fs.lstat),
+  realpath = promisify(fs.realpath),
+  createReadStream = fs.createReadStream,
+  stat = promisify(fs.stat)
+
+export type MultiStreams = (Readable | (() => Readable))[]
 
 function makeRelative(cwd: string, path: string) {
   return './' + relative(cwd, path)
 }
 
+function sortEntry(a: [string, File], b: [string, File]) {
+  return a[0] > b[0] ? 1 : -1
+}
+
 export function toStream(content: Buffer | string) {
-  const readable = new Readable({ read() {} })
-  readable.push(content)
-  readable.push(null)
+  const readable = new Readable({
+    read() {
+      this.push(content)
+      this.push(null)
+    },
+  })
   return readable
 }
 
-export type File = { absPath: string; contents: string; deps: FileMap }
-export type FileMap = { [absPath: string]: File | null }
-
-export interface BundleOptions {
-  entries: string[]
-  cwd: string
-  expand: boolean
-  loadContent: boolean
-  files: FileMap
+async function createFile(absoluteFileName: string) {
+  const stats = await lstat(absoluteFileName),
+    file: File = {
+      size: stats.size,
+      contents: '',
+      absPath: absoluteFileName,
+      deps: {},
+    }
+  if (stats.isSymbolicLink()) {
+    file.size = stats.size
+    const [realPath, realStat] = await Promise.all([
+      realpath(absoluteFileName),
+      stat(absoluteFileName),
+    ])
+    file.realPath = realPath
+    file.realSize = realStat.size
+  }
+  return file
 }
 
 export class Bundle {
+  size = 0
+  cwd: string
+  rendered = false
+  private offset = 0
+  private index: { [key: string]: [number, number] } = {}
+  private files: { [key: string]: File } = {}
+  streams: MultiStreams = []
   constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
     this.cwd = cwd
   }
-  cwd: string
-  blobSize: number = 0
-  index: { [relativeFilePath: string]: [number, number] } = {}
-  streams: (Readable | (() => Readable))[] = []
 
-  async addResource(absoluteFileName: string, content?: Buffer | string) {
-    let length = 0
-    if (content !== undefined) {
-      length = Buffer.byteLength(content)
-    } else {
-      const stats = await stat(absoluteFileName)
-      length = stats.size
-    }
-
-    const start = this.blobSize
-
-    this.blobSize += length
-    this.index[makeRelative(this.cwd, absoluteFileName)] = [start, length]
-    this.streams.push(() => (content ? toStream(content) : createReadStream(absoluteFileName)))
+  get list() {
+    return Object.keys(this.files)
   }
 
-  concat() {
-    throw new Error('Not Implemented')
+  public async addResource(
+    absoluteFileName: string,
+    content?: File | Buffer | string
+  ): Promise<number> {
+    if (this.files[absoluteFileName]) {
+      return this.size
+    }
+    if (typeof content === 'string' || Buffer.isBuffer(content)) {
+      this.files[absoluteFileName] = {
+        size: Buffer.byteLength(content),
+        contents: content as any, //todo type is wrong here... should allow buffer
+        deps: {},
+        absPath: absoluteFileName,
+      }
+    } else if (content) {
+      this.files[content.absPath] = content
+    } else {
+      this.files[absoluteFileName] = {
+        absPath: absoluteFileName,
+        contents: '',
+        deps: {},
+        size: 0,
+      }
+      this.files[absoluteFileName] = await createFile(absoluteFileName)
+    }
+    return (this.size += this.files[absoluteFileName].size)
+  }
+
+  /**
+   * De-dupe files by absolute path, partition by symlink/real
+   * Iterate over real, add entries
+   * Iterate over symlinks, add symlinks
+   */
+  renderIndex() {
+    if (this.rendered) {
+      throw new Error('Bundle index already rendered')
+    }
+    const files = Object.entries(this.files),
+      realFiles: [string, File][] = [],
+      symLinks: [string, File][] = []
+    for (const entry of files) {
+      if (entry[1].realPath) {
+        symLinks.push(entry)
+      } else {
+        realFiles.push(entry)
+      }
+    }
+    realFiles.sort(sortEntry)
+    symLinks.sort(sortEntry)
+
+    for (const [absPath, file] of realFiles) {
+      this.addEntry(absPath, file)
+    }
+    for (const [absPath, file] of symLinks) {
+      this.addEntry(file.realPath as string, file)
+      this.addEntry(absPath, file, file.realPath)
+    }
+    this.rendered = true
+    return this.index
+  }
+
+  /**
+   * Add a stream if needed and an entry with the required offset and size
+   * Ensure the calling order of this method is idempotent (eg, while iterating a sorted set)
+   * @param entryPath
+   * @param file
+   * @param useEntry
+   */
+  addEntry(entryPath: string, file: File, useEntry?: string) {
+    const existingName = useEntry && makeRelative(this.cwd, useEntry),
+      name = makeRelative(this.cwd, entryPath),
+      size = file.realSize ?? file.size,
+      existingEntry = this.index[existingName ?? name]
+
+    this.index[name] = existingEntry || [this.offset, size]
+    if (!existingEntry) {
+      this.streams.push(() =>
+        file.contents ? toStream(file.contents) : createReadStream(file.absPath)
+      )
+      this.offset += size
+    }
   }
 
   toStream() {
-    return combineStreams(this.streams)
-  }
-
-  toJSON() {
-    return this.index
+    return new (MultiStream as any)(this.streams)
   }
 }

src/fs/patch.ts

@@ -1,4 +1,5 @@
 import { Stats } from 'fs'
+import { getLatestGitRelease } from '../releases'
 
 export interface NexeBinary {
   blobPath: string
@@ -13,40 +14,42 @@ export interface NexeBinary {
 }
 
 let originalFsMethods: any = null
-let nexeBinary: NexeBinary | null = null
+let lazyRestoreFs = () => {}
 
-function restoreFs(fs: any = require('fs')): NexeBinary | false {
-  if (!nexeBinary) {
-    return false
-  }
-  const source = nexeBinary
-  Object.assign(fs, originalFsMethods)
-  nexeBinary = originalFsMethods = null
-  return source
-}
+// optional Win32 file namespace prefix followed by drive letter and colon
+const windowsFullPathRegex = /^(\\{2}\?\\)?([a-zA-Z]):/
+
+const upcaseDriveLetter = (s: string): string =>
+  s.replace(windowsFullPathRegex, (_match, ns, drive) => `${ns || ''}${drive.toUpperCase()}:`)
 
 function shimFs(binary: NexeBinary, fs: any = require('fs')) {
   if (originalFsMethods !== null) {
     return
   }
   originalFsMethods = Object.assign({}, fs)
-  nexeBinary = binary
-  const { blobPath, resources: manifest } = binary
-  const { resourceStart, stat } = binary.layout
-  const directories: { [key: string]: { [key: string]: boolean } } = {},
+  const { blobPath, resources: manifest } = binary,
+    { resourceStart, stat } = binary.layout,
+    directories: { [key: string]: { [key: string]: boolean } } = {},
     notAFile = '!@#$%^&*',
     isWin = process.platform.startsWith('win'),
     isString = (x: any): x is string => typeof x === 'string' || x instanceof String,
-    isNotFile = () => false,
-    isNotDirectory = isNotFile,
-    isFile = () => true,
     noop = () => {},
-    isDirectory = isFile,
-    path = require('path')
+    path = require('path'),
+    winPath: (key: string) => string = isWin ? upcaseDriveLetter : (s) => s,
+    baseDir = winPath(path.dirname(process.execPath))
 
-  let log = (text: string) => true
+  let log = (_: string) => true
+  let loggedManifest = false
   if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
-    log = (text: string) => process.stderr.write('[nexe] - ' + text + '\n')
+    log = (text: string) => {
+      setupManifest()
+      if (!loggedManifest) {
+        process.stderr.write('[nexe] - MANIFEST' + JSON.stringify(manifest, null, 4) + '\n')
+        process.stderr.write('[nexe] - DIRECTORIES' + JSON.stringify(directories, null, 4) + '\n')
+        loggedManifest = true
+      }
+      return process.stderr.write('[nexe] - ' + text + '\n')
+    }
   }
 
   const getKey = function getKey(filepath: string | Buffer | null): string {
@@ -56,15 +59,12 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
     if (!isString(filepath)) {
       return notAFile
     }
-    let key = path.resolve(filepath)
+    let key = path.resolve(baseDir, filepath)
 
-    if (isWin && key.substr(1, 2) === ':\\') {
-      key = key[0].toUpperCase() + key.substr(1)
-    }
-    return key
+    return winPath(key)
   }
 
-  const statTime = function() {
+  const statTime = function () {
     return {
       dev: 0,
       ino: 0,
@@ -81,25 +81,57 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       ctime: new Date(stat.ctime),
       ctimMs: stat.ctime.getTime(),
       birthtime: new Date(stat.birthtime),
-      birthtimeMs: stat.birthtime.getTime()
+      birthtimeMs: stat.birthtime.getTime(),
     }
   }
 
-  const createStat = function(extensions: any) {
-    return Object.assign(new fs.Stats(), binary.layout.stat, statTime(), extensions)
+  let BigInt: Function
+  try {
+    BigInt = eval('BigInt')
+  } catch (ignored) {}
+
+  const createStat = function (extensions: any, options: any) {
+    const stat = Object.assign(new fs.Stats(), binary.layout.stat, statTime(), extensions)
+    if (options && options.bigint && BigInt) {
+      for (const k in stat) {
+        if (Object.prototype.hasOwnProperty.call(stat, k) && typeof stat[k] === 'number') {
+          stat[k] = BigInt(stat[k])
+        }
+      }
+    }
+    return stat
   }
 
-  const ownStat = function(filepath: any) {
+  const ownStat = function (filepath: any, options: any) {
     setupManifest()
     const key = getKey(filepath)
     if (directories[key]) {
       let mode = binary.layout.stat.mode
       mode |= fs.constants.S_IFDIR
       mode &= ~fs.constants.S_IFREG
-      return createStat({ mode, size: 0 })
+      return createStat({ mode, size: 0 }, options)
     }
     if (manifest[key]) {
-      return createStat({ size: manifest[key][1] })
+      return createStat({ size: manifest[key][1] }, options)
+    }
+  }
+
+  const getStat = function (fn: string) {
+    return function stat(filepath: string | Buffer, options: any, callback: any) {
+      let stat: any
+      if (typeof options === 'function') {
+        callback = options
+        stat = ownStat(filepath, null)
+      } else {
+        stat = ownStat(filepath, options)
+      }
+      if (stat) {
+        process.nextTick(() => {
+          callback(null, stat)
+        })
+      } else {
+        return originalFsMethods[fn].apply(fs, arguments)
+      }
     }
   }
 
@@ -112,11 +144,11 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
   }
 
   let setupManifest = () => {
-    Object.keys(manifest).forEach(filepath => {
+    Object.keys(manifest).forEach((filepath) => {
       const entry = manifest[filepath]
       const absolutePath = getKey(filepath)
       const longPath = makeLong(absolutePath)
-      const normalizedPath = path.normalize(filepath)
+      const normalizedPath = winPath(path.normalize(filepath))
 
       if (!manifest[absolutePath]) {
         manifest[absolutePath] = entry
@@ -206,25 +238,28 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       const encoding = fileOpts(options).encoding
       callback = typeof options === 'function' ? options : callback
 
-      fs.open(blobPath, 'r', function(err: Error, fd: number) {
+      originalFsMethods.open(blobPath, 'r', function (err: Error, fd: number) {
         if (err) return callback(err, null)
-        fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function(
-          error: Error,
-          bytesRead: number,
-          result: Buffer
-        ) {
-          if (error) {
-            return fs.close(fd, function() {
-              callback(error, null)
+        originalFsMethods.read(
+          fd,
+          Buffer.alloc(length),
+          0,
+          length,
+          resourceOffset,
+          function (error: Error, bytesRead: number, result: Buffer) {
+            if (error) {
+              return originalFsMethods.close(fd, function () {
+                callback(error, null)
+              })
+            }
+            originalFsMethods.close(fd, function (err: Error) {
+              if (err) {
+                return callback(err, result)
+              }
+              callback(err, encoding ? result.toString(encoding) : result)
             })
           }
-          fs.close(fd, function(err: Error) {
-            if (err) {
-              return callback(err, result)
-            }
-            callback(err, encoding ? result.toString(encoding) : result)
-          })
-        })
+        )
       })
     },
     createReadStream: function createReadStream(filepath: any, options: any) {
@@ -237,11 +272,11 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       const resourceOffset = resourceStart + offset
       const opts = fileOpts(options)
 
-      return fs.createReadStream(
+      return originalFsMethods.createReadStream(
         blobPath,
         Object.assign({}, opts, {
           start: resourceOffset,
-          end: resourceOffset + length - 1
+          end: resourceOffset + length - 1,
         })
       )
     },
@@ -254,33 +289,31 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       const [offset, length] = entry
       const resourceOffset = resourceStart + offset
       const encoding = fileOpts(options).encoding
-      const fd = fs.openSync(process.execPath, 'r')
+      const fd = originalFsMethods.openSync(process.execPath, 'r')
       const result = Buffer.alloc(length)
-      fs.readSync(fd, result, 0, length, resourceOffset)
-      fs.closeSync(fd)
+      originalFsMethods.readSync(fd, result, 0, length, resourceOffset)
+      originalFsMethods.closeSync(fd)
       return encoding ? result.toString(encoding) : result
     },
-    statSync: function statSync(filepath: string | Buffer) {
-      const stat = ownStat(filepath)
+    statSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
       if (stat) {
         return stat
       }
       return originalFsMethods.statSync.apply(fs, arguments)
     },
-    stat: function stat(filepath: string | Buffer, callback: any) {
-      const stat = ownStat(filepath)
+    stat: getStat('stat'),
+    lstat: getStat('lstat'),
+    lstatSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
       if (stat) {
-        process.nextTick(() => {
-          callback(null, stat)
-        })
-      } else {
-        return originalFsMethods.stat.apply(fs, arguments)
+        return stat
       }
-    }
+      return originalFsMethods.lstatSync.apply(fs, arguments)
+    },
   }
-
   if (typeof fs.exists === 'function') {
-    nfs.exists = function(filepath: string, cb: Function) {
+    nfs.exists = function (filepath: string, cb: Function) {
       cb = cb || noop
       const exists = nfs.existsSync(filepath)
       process.nextTick(() => cb(exists))
@@ -289,9 +322,9 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
 
   const patches = (process as any).nexe.patches || {}
   delete (process as any).nexe
-  patches.internalModuleReadFile = function(this: any, original: any, ...args: any[]) {
-    const [filepath] = args
+  patches.internalModuleReadFile = function (this: any, original: any, ...args: any[]) {
     setupManifest()
+    const filepath = getKey(args[0])
     if (manifest[filepath]) {
       log('read     (hit)              ' + filepath)
       return nfs.readFileSync(filepath, 'utf-8')
@@ -299,10 +332,17 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
     log('read          (miss)       ' + filepath)
     return original.call(this, ...args)
   }
-  patches.internalModuleReadJSON = patches.internalModuleReadFile
-  patches.internalModuleStat = function(this: any, original: any, ...args: any[]) {
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (returningArray == null) returningArray = Array.isArray(original.call(this, ''))
+    const res = patches.internalModuleReadFile.call(this, original, ...args)
+    return returningArray && !Array.isArray(res)
+      ? [res, /"(main|name|type|exports|imports)"/.test(res)]
+      : res
+  }
+  patches.internalModuleStat = function (this: any, original: any, ...args: any[]) {
     setupManifest()
-    const [filepath] = args
+    const filepath = getKey(args[0])
     if (manifest[filepath]) {
       log('stat     (hit)              ' + filepath + '   ' + 0)
       return 0
@@ -323,7 +363,7 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
   }
 
   if (typeof fs.exists === 'function') {
-    nfs.exists = function(filepath: string, cb: Function) {
+    nfs.exists = function (filepath: string, cb: Function) {
       cb = cb || noop
       const exists = nfs.existsSync(filepath)
       if (!exists) {
@@ -332,8 +372,53 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       process.nextTick(() => cb(exists))
     }
   }
+
+  if (typeof fs.copyFile === 'function') {
+    nfs.copyFile = function (filepath: string, dest: string, flags: number, callback: Function) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFile.apply(fs, arguments)
+      }
+      if (typeof flags === 'function') {
+        callback = flags
+        flags = 0
+      }
+      nfs.readFile(filepath, (err: any, buffer: any) => {
+        if (err) {
+          return callback(err)
+        }
+        originalFsMethods.writeFile(dest, buffer, (err: any) => {
+          if (err) {
+            return callback(err)
+          }
+          callback(null)
+        })
+      })
+    }
+    nfs.copyFileSync = function (filepath: string, dest: string) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFileSync.apply(fs, arguments)
+      }
+      return originalFsMethods.writeFileSync(dest, nfs.readFileSync(filepath))
+    }
+  }
+
   Object.assign(fs, nfs)
+
+  lazyRestoreFs = () => {
+    Object.keys(nfs).forEach((key) => {
+      fs[key] = originalFsMethods[key]
+    })
+    lazyRestoreFs = () => {}
+  }
   return true
 }
 
+function restoreFs() {
+  lazyRestoreFs()
+}
+
 export { shimFs, restoreFs }

src/logger.ts

@@ -24,7 +24,7 @@ export class Logger {
       this.ora = ora({
         text: 'Starting...',
         color: 'blue',
-        spinner: 'dots'
+        spinner: 'dots',
       })
       this.ora.stop()
     }
@@ -35,7 +35,7 @@ export class Logger {
 
   flush() {
     !this.silent && this.ora.succeed()
-    return new Promise(resolve => setTimeout(resolve, frameLength))
+    return new Promise((resolve) => setTimeout(resolve, frameLength))
   }
 
   _write(update: string, color = 'green') {
@@ -66,7 +66,7 @@ export class Logger {
       modify: this.modify,
       log: this.verbose ? this.write : this.modify,
       pause: () => this.ora.stopAndPersist(),
-      resume: () => this.ora.start()
+      resume: () => this.ora.start(),
     } as LogStep
   }
 }

src/options.ts

@@ -5,7 +5,7 @@ import { basename, extname, join, isAbsolute, resolve } from 'path'
 import { getTarget, NexeTarget } from './target'
 import { EOL, homedir } from 'os'
 import chalk from 'chalk'
-import { resolveFileNameSync } from 'resolve-dependencies'
+import { resolveSync } from 'resolve-dependencies'
 const caw = require('caw')
 const c = process.platform === 'win32' ? chalk.constructor({ enabled: false }) : chalk
 
@@ -21,7 +21,10 @@ export interface NexeOptions {
   output: string
   targets: (string | NexeTarget)[]
   name: string
+  remote: string
+  asset: string
   cwd: string
+  fs: boolean | string[]
   flags: string[]
   configure: string[]
   vcBuild: string[]
@@ -35,11 +38,6 @@ export interface NexeOptions {
   patches: (string | NexePatch)[]
   plugins: (string | NexePatch)[]
   native: any
-  /**
-   * @deprecated
-   * Use mangle: false instead
-   */
-  empty: boolean
   mangle: boolean
   ghToken: string
   sourceUrl?: string
@@ -53,7 +51,6 @@ export interface NexeOptions {
   ico?: string
   debugBundle?: boolean
   warmup?: string
-  compress?: boolean
   clean?: boolean
   /**
    * Api Only
@@ -64,26 +61,28 @@ export interface NexeOptions {
 const defaults = {
   flags: [],
   cwd: process.cwd(),
+  fs: true,
   configure: [],
+  mangle: true,
   make: [],
   targets: [],
   vcBuild: isWindows ? ['nosign', 'release'] : [],
   enableNodeCli: false,
-  compress: false,
   build: false,
   bundle: true,
   patches: [],
-  plugins: []
+  plugins: [],
+  remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
 }
 const alias = {
   i: 'input',
   o: 'output',
   v: 'version',
+  a: 'asset',
   t: 'target',
   b: 'build',
   n: 'name',
   r: 'resource',
-  a: 'resource',
   p: 'python',
   f: 'flag',
   c: 'configure',
@@ -91,7 +90,7 @@ const alias = {
   h: 'help',
   l: 'loglevel',
   'fake-argv': 'fakeArgv',
-  'gh-token': 'ghToken'
+  'gh-token': 'ghToken',
 }
 const argv = parseArgv(process.argv, { alias, default: { ...defaults } })
 let help = `
@@ -104,6 +103,7 @@ ${c.bold('nexe <entry-file> [options]')}
   -t   --target                     -- node version description
   -n   --name                       -- main app module name
   -r   --resource                   -- *embed files (glob) within the binary
+       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
        --plugin                     -- extend nexe runtime behavior
 
    ${c.underline.bold('Building from source:')}
@@ -113,7 +113,8 @@ ${c.bold('nexe <entry-file> [options]')}
   -f   --flag                       -- *v8 flags to include during compilation
   -c   --configure                  -- *arguments to the configure step
   -m   --make                       -- *arguments to the make/build step
-       --no-mangle                  -- used when generating base binaries, or when pathing _third_party_main manually.
+       --patch                      -- module with middleware default export for adding a build patch
+       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
        --snapshot                   -- path to a warmup snapshot
        --ico                        -- file name for alternate icon file (windows)
        --rc-*                       -- populate rc file options (windows)
@@ -134,7 +135,7 @@ ${c.bold('nexe <entry-file> [options]')}
 help = EOL + help + EOL
 
 function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter(x => x)
+  return ([] as string[]).concat(...args).filter((x) => x)
 }
 
 /**
@@ -145,16 +146,13 @@ function flatten(...args: any[]): string[] {
  */
 function extractCliMap(match: RegExp, options: any) {
   return Object.keys(options)
-    .filter(x => match.test(x))
-    .reduce(
-      (map: any, option: any) => {
-        const key = option.split('-')[1]
-        map[key] = options[option]
-        delete options[option]
-        return map
-      },
-      {} as any
-    )
+    .filter((x) => match.test(x))
+    .reduce((map: any, option: any) => {
+      const key = option.split('-')[1]
+      map[key] = options[option]
+      delete options[option]
+      return map
+    }, {} as any)
 }
 
 function extractLogLevel(options: NexeOptions) {
@@ -209,17 +207,17 @@ export function resolveEntry(
   }
   if (input) {
     const inputPath = padRelative(input)
-    result = resolveFileNameSync(cwd, inputPath)
+    result = resolveSync(cwd, inputPath)
   }
   if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
     const inputPath = padRelative(maybeEntry)
-    result = resolveFileNameSync(cwd, inputPath)
+    result = resolveSync(cwd, inputPath)
   }
   if (!process.stdin.isTTY && (!result || !result.absPath) && bundle === defaults.bundle) {
     return STDIN_FLAG
   }
   if (!result || !result.absPath) {
-    result = resolveFileNameSync(cwd, '.')
+    result = resolveSync(cwd, '.')
   }
   if (!result.absPath) {
     throw new NexeError(`Entry file "${input || ''}" not found!`)
@@ -253,6 +251,10 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
   options.configure = flatten(options.configure)
   options.resources = flatten(opts.resource, options.resources)
 
+  if (!options.remote.endsWith('/')) {
+    options.remote += '/'
+  }
+
   options.downloadOptions = options.downloadOptions || {}
   options.downloadOptions.headers = options.downloadOptions.headers || {}
   options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)'
@@ -268,6 +270,21 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
       : `${options.output || options.name}`
   options.output = resolve(cwd, options.output)
 
+  const requireDefault = (x: string) => {
+    if (typeof x === 'string') {
+      return require(x).default
+    }
+    return x
+  }
+
+  options.mangle = 'mangle' in opts ? opts.mangle : true
+  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
+  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
+
+  if ((!options.mangle && !options.bundle) || options.patches.length) {
+    options.build = true
+  }
+
   if (options.build) {
     const { arch } = options.targets[0] as NexeTarget
     if (isWindows) {
@@ -277,20 +294,9 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
     }
   }
 
-  const requireDefault = (x: string) => {
-    if (typeof x === 'string') {
-      return require(x).default
-    }
-    return x
-  }
-
-  options.mangle = 'mangle' in opts ? opts.mangle : !opts.empty
-  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
-  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
-
   Object.keys(alias)
-    .filter(k => k !== 'rc')
-    .forEach(x => delete opts[x])
+    .filter((k) => k !== 'rc')
+    .forEach((x) => delete opts[x])
 
   return options
 }

src/patches/boot-nexe.ts

@@ -1,29 +1,32 @@
 const fs = require('fs'),
   fd = fs.openSync(process.execPath, 'r'),
   stat = fs.statSync(process.execPath),
-  footer = Buffer.alloc(32, 0)
+  tailSize = Math.min(stat.size, 16000),
+  tailWindow = Buffer.from(Array(tailSize))
 
-fs.readSync(fd, footer, 0, 32, stat.size - 32)
+fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize)
 
-if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
+const footerPosition = tailWindow.indexOf('<nexe~~sentinel>')
+if (footerPosition == -1) {
   throw 'Invalid Nexe binary'
 }
 
-const contentSize = footer.readDoubleLE(16),
+const footer = tailWindow.slice(footerPosition, footerPosition + 32),
+  contentSize = footer.readDoubleLE(16),
   resourceSize = footer.readDoubleLE(24),
-  contentStart = stat.size - 32 - resourceSize - contentSize,
+  contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize,
   resourceStart = contentStart + contentSize
 
 Object.defineProperty(
   process,
   '__nexe',
-  (function() {
+  (function () {
     let nexeHeader: any = null
     return {
-      get: function() {
+      get: function () {
         return nexeHeader
       },
-      set: function(value: any) {
+      set: function (value: any) {
         if (nexeHeader) {
           throw new Error('This property is readonly')
         }
@@ -34,13 +37,13 @@ Object.defineProperty(
             contentSize,
             contentStart,
             resourceSize,
-            resourceStart
-          }
+            resourceStart,
+          },
         })
         Object.freeze(nexeHeader)
       },
       enumerable: false,
-      configurable: false
+      configurable: false,
     }
   })()
 )

src/patches/disable-node-cli.ts

@@ -9,11 +9,11 @@ export default async function disableNodeCli(compiler: NexeCompiler, next: () =>
   if (semverGt(compiler.target.version, '11.6.0')) {
     await compiler.replaceInFileAsync(
       'src/node.cc',
-      /(?<!int )ProcessGlobalArgs\(/g,
-      '0;//ProcessGlobalArgs('
+      /(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm,
+      '0;/*$&*/'
     )
   } else if (semverGt(compiler.target.version, '10.9')) {
-    await compiler.replaceInFileAsync('src/node.cc', /(?<!void )ProcessArgv\(/g, '//ProcessArgv(')
+    await compiler.replaceInFileAsync('src/node.cc', /(?<!void )ProcessArgv\(argv/g, '//$&')
   } else if (semverGt(compiler.target.version, '9.999')) {
     await compiler.replaceInFileAsync(
       'src/node.cc',
@@ -21,7 +21,7 @@ export default async function disableNodeCli(compiler: NexeCompiler, next: () =>
       'int i = v8_argc; i < v8_argc; i++'
     )
     let matches = 0
-    await compiler.replaceInFileAsync('src/node.cc', /v8_argc > 1/g, match => {
+    await compiler.replaceInFileAsync('src/node.cc', /v8_argc > 1/g, (match) => {
       if (matches++) {
         return 'false'
       }

src/patches/gyp.ts

@@ -13,8 +13,8 @@ export default async function nodeGyp(
     `
     ${nodeGypMarker}
     ${files
-      .filter(x => x.filename.startsWith('lib'))
-      .map(x => `'${x.filename}'`)
+      .filter((x) => x.filename.startsWith('lib'))
+      .map((x) => `'${x.filename}'`)
       .toString()},
   `.trim()
   )

src/patches/node-rc.ts

@@ -8,18 +8,19 @@ export default async function nodeRc(compiler: NexeCompiler, next: () => Promise
 
   const file = await compiler.readFileAsync('src/res/node.rc')
 
-  Object.keys(options).forEach(key => {
+  Object.keys(options).forEach((key) => {
     let value = options[key]
     const isVar = /^[A-Z_]+$/.test(value)
     value = isVar ? value : `"${value}"`
-    file.contents = file.contents.replace(
-      new RegExp(`VALUE "${key}",.*`),
-      `VALUE "${key}", ${value}`
-    )
+    file.contents = file.contents
+      .toString()
+      .replace(new RegExp(`VALUE "${key}",.*`), `VALUE "${key}", ${value}`)
   })
-  ;['PRODUCTVERSION', 'FILEVERSION'].forEach(x => {
+  ;['PRODUCTVERSION', 'FILEVERSION'].forEach((x) => {
     if (options[x]) {
-      file.contents = file.contents.replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
+      file.contents = file.contents
+        .toString()
+        .replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
     }
   })
 

src/patches/snapshot.ts

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

src/patches/third-party-main.ts

@@ -1,6 +1,6 @@
 import { NexeCompiler } from '../compiler'
 import { parse } from 'cherow'
-import { semverGt } from '../util'
+import { wrap, semverGt } from '../util'
 
 function walkSome(node: any, visit: Function) {
   if (!node || typeof node.type !== 'string' || node._visited) {
@@ -29,18 +29,20 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
 
   if (version.startsWith('4.')) {
     bootFile = 'src/node.js'
+  } else if (semverGt(version, '11.99')) {
+    bootFile = 'lib/internal/bootstrap/pre_execution.js'
   } else if (semverGt(version, '9.10.1')) {
     bootFile = 'lib/internal/bootstrap/node.js'
   }
 
   const file = await compiler.readFileAsync(bootFile),
-    ast = parse(file.contents, {
+    ast = parse(file.contents.toString(), {
       loc: true,
       tolerant: true,
       next: true,
       globalReturn: true,
       node: true,
-      skipShebang: true
+      skipShebang: true,
     }),
     location = { start: { line: 0 } }
 
@@ -52,13 +54,56 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
     }
   })
 
-  const fileLines = file.contents.split('\n')
-  fileLines.splice(location.start.line, 0, '{{replace:lib/fs/bootstrap.js}}' + '\n')
+  const fileLines = file.contents.toString().split('\n')
+  fileLines.splice(
+    location.start.line,
+    0,
+    '{{replace:lib/fs/bootstrap.js}}' +
+      '\n' +
+      (semverGt(version, '11.99') ? 'expandArgv1 = false;\n' : '')
+  )
   file.contents = fileLines.join('\n')
 
-  await compiler.setFileContentsAsync(
-    'lib/_third_party_main.js',
-    '{{replace:lib/patches/boot-nexe.js}}'
-  )
+  if (semverGt(version, '11.99')) {
+    if (semverGt(version, '12.17.99')) {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializeFrozenIntrinsics();',
+        'initializeFrozenIntrinsics();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializePolicy();',
+        'initializePolicy();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+      )
+    }
+    await compiler.replaceInFileAsync(
+      bootFile,
+      'assert(!CJSLoader.hasLoadedAnyUserCJSModule)',
+      '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/'
+    )
+    const { contents: nodeccContents } = await compiler.readFileAsync('src/node.cc')
+    if (nodeccContents.includes('if (env->worker_context() != nullptr) {')) {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'if (env->worker_context() != nullptr) {',
+        'if (env->worker_context() == nullptr) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module"); } else {\n'
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module");\n'
+      )
+    }
+  } else {
+    await compiler.setFileContentsAsync(
+      'lib/_third_party_main.js',
+      '{{replace:lib/patches/boot-nexe.js}}'
+    )
+  }
   return next()
 }

src/releases.ts

@@ -2,7 +2,7 @@ import got = require('got')
 import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target'
 export { NexeTarget }
 
-const versionsToSkip = [0, 1, 2, 3, 4, 5, 7, 9, 11]
+const versionsToSkip = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22]
 export interface GitAsset {
   name: string
   url: string
@@ -25,8 +25,10 @@ async function getJson<T>(url: string, options?: any) {
 }
 
 function isBuildableVersion(version: string) {
-  const major = Number(version.split('.')[0])
-  return !versionsToSkip.includes(major) || version === '4.8.4'
+  if (version === '12.11.0') {
+    return false
+  }
+  return !versionsToSkip.includes(Number(version.split('.')[0]))
 }
 
 export function getLatestGitRelease(options?: any) {
@@ -37,7 +39,7 @@ export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
     'https://nodejs.org/download/release/index.json'
   )
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(x => getTarget(x.name))
+  const existingVersions = (await getLatestGitRelease(options)).assets.map((x) => getTarget(x.name))
 
   const versionMap: { [key: string]: true } = {}
   return nodeReleases
@@ -47,8 +49,8 @@ export async function getUnBuiltReleases(options?: any) {
         return versions
       }
       versionMap[version] = true
-      platforms.forEach(platform => {
-        architectures.forEach(arch => {
+      platforms.forEach((platform) => {
+        architectures.forEach((arch) => {
           if (arch === 'x86' && platform === 'mac') return
           if (arch.includes('arm')) return
           versions.push(getTarget({ platform, arch, version }))
@@ -56,5 +58,5 @@ export async function getUnBuiltReleases(options?: any) {
       })
       return versions
     }, [])
-    .filter(x => !existingVersions.some(t => targetsEqual(t, x)))
+    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)))
 }

src/steps/artifacts.ts

@@ -1,29 +1,28 @@
 import { join, dirname } from 'path'
-import { readdir, unlink } from 'fs'
+import * as fs from 'fs'
+import { promisify } from 'util'
 import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
-import * as mkdirp from 'mkdirp'
+import mkdirpAsync = require('mkdirp')
 import { NexeCompiler } from '../compiler'
-import pify = require('pify')
 
-const mkdirpAsync = pify(mkdirp)
-const unlinkAsync = pify(unlink)
-const readdirAsync = pify(readdir)
+const unlinkAsync = promisify(fs.unlink),
+  readdirAsync = promisify(fs.readdir)
 
 function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then(paths => {
+  return readdirAsync(dir).then((paths) => {
     return Promise.all(
       paths.map((file: string) => {
         const path = join(dir, file)
-        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : (path as any)))
+        return isDirectoryAsync(path).then((x) => (x ? readDirAsync(path) : (path as any)))
       })
-    ).then(result => {
+    ).then((result) => {
       return [].concat(...(result as any))
     })
   })
 }
 
 function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, 'utf-8').catch(e => {
+  return readFileAsync(file, 'utf-8').catch((e) => {
     if (e.code === 'ENOENT') {
       return ''
     }
@@ -47,16 +46,16 @@ export default async function artifacts(compiler: NexeCompiler, next: () => Prom
   const tmpFiles = await readDirAsync(temp)
 
   await Promise.all(
-    tmpFiles.map(async path => {
+    tmpFiles.map(async (path) => {
       return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
     })
   )
 
   await next()
 
-  await Promise.all(tmpFiles.map(x => unlinkAsync(x)))
+  await Promise.all(tmpFiles.map((x) => unlinkAsync(x)))
   return Promise.all(
-    compiler.files.map(async file => {
+    compiler.files.map(async (file) => {
       const sourceFile = join(src, file.filename)
       const tempFile = join(temp, file.filename)
       const fileContents = await maybeReadFileContentsAsync(sourceFile)

src/steps/bundle.ts

@@ -1,13 +1,12 @@
 import { NexeCompiler, NexeError } from '../compiler'
 import { resolve, relative } from 'path'
-import { each } from '@calebboyd/semaphore'
-import resolveFiles from 'resolve-dependencies'
-import { dequote, STDIN_FLAG } from '../util'
+import resolveFiles, { resolveSync } from 'resolve-dependencies'
+import { dequote, STDIN_FLAG, semverGt, each } from '../util'
 import { Readable } from 'stream'
 
 function getStdIn(stdin: Readable): Promise<string> {
-  return new Promise(resolve => {
-    let out = ''
+  let out = ''
+  return new Promise((resolve) => {
     stdin
       .setEncoding('utf8')
       .on('readable', () => {
@@ -16,47 +15,71 @@ function getStdIn(stdin: Readable): Promise<string> {
           out += current
         }
       })
-      .on('end', () => resolve(out))
+      .on('end', () => resolve(out.trim()))
+    setTimeout(() => {
+      if (!out.trim()) {
+        resolve(out.trim())
+      }
+    }, 1000)
   })
 }
 
 export default async function bundle(compiler: NexeCompiler, next: any) {
-  const { bundle, cwd, input } = compiler.options
+  const { bundle: doBundle, cwd, input: inputPath } = compiler.options
+  let input = inputPath
   compiler.entrypoint = './' + relative(cwd, input)
-  compiler.startup = ';require("module").runMain();'
 
-  if (!bundle) {
+  if (semverGt(compiler.target.version, '11.99')) {
+    compiler.startup = ''
+  } else {
+    compiler.startup = ';require("module").runMain();'
+  }
+
+  if (!doBundle) {
     await compiler.addResource(resolve(cwd, input))
     return next()
   }
 
   let code = ''
-  if (typeof bundle === 'string') {
-    code = await require(bundle).createBundle(compiler.options)
+  if (typeof doBundle === 'string') {
+    code = await require(doBundle).createBundle(compiler.options)
   }
 
-  if (input === STDIN_FLAG) {
+  if (input === STDIN_FLAG && (code = code || dequote(await getStdIn(process.stdin)))) {
     compiler.stdinUsed = true
     compiler.entrypoint = './__nexe_stdin.js'
-    code = code || dequote(await getStdIn(process.stdin))
     await compiler.addResource(resolve(cwd, compiler.entrypoint), code)
     return next()
   }
 
-  const { files, warnings } = await resolveFiles(
+  if (input === STDIN_FLAG) {
+    const maybeInput = resolveSync(cwd, '.')
+    if (!maybeInput || !maybeInput.absPath) {
+      throw new NexeError('No valid input detected')
+    }
+    input = maybeInput.absPath
+    compiler.entrypoint = './' + relative(cwd, input)
+  }
+
+  const { files, warnings } = resolveFiles(
     input,
-    ...Object.keys(compiler.bundle.index).filter(x => x.endsWith('.js')),
-    { cwd, expand: true, loadContent: false }
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js')),
+    { cwd, expand: 'variable', loadContent: false }
   )
 
   if (
-    warnings.filter(x => x.startsWith('Error parsing file') && !x.includes('node_modules')).length
+    warnings.filter((x) => x.startsWith('Error parsing file') && !x.includes('node_modules')).length
   ) {
     throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
   }
 
-  await each(Object.keys(files), (filename: string) => compiler.addResource(filename), {
-    concurrency: 10
-  })
+  //TODO: warnings.forEach((x) => console.log(x))
+
+  await Promise.all(
+    Object.entries(files).map(([key, file]) => {
+      return compiler.addResource(key, file)
+    })
+  )
+
   return next()
 }

src/steps/cli.ts

@@ -1,8 +1,9 @@
-import { normalize, relative } from 'path'
+import { dirname, normalize, relative, resolve } from 'path'
 import { createWriteStream, chmodSync, statSync } from 'fs'
 import { NexeCompiler } from '../compiler'
 import { NexeTarget } from '../target'
 import { STDIN_FLAG } from '../util'
+import mkdirp = require('mkdirp')
 
 /**
  * The "cli" step detects the appropriate input. If no input options are passed,
@@ -16,30 +17,42 @@ import { STDIN_FLAG } from '../util'
  */
 export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
   await next()
-  const { log } = compiler
-  const target = compiler.options.targets.shift() as NexeTarget
-  const deliverable = await compiler.compileAsync(target)
+  const { log } = compiler,
+    target = compiler.options.targets.shift() as NexeTarget,
+    deliverable = await compiler.compileAsync(target),
+    output = normalize(compiler.output!)
 
-  return new Promise((resolve, reject) => {
+  mkdirp.sync(dirname(output))
+
+  return new Promise((res, rej) => {
     const step = log.step('Writing result to file')
     deliverable
-      .pipe(createWriteStream(normalize(compiler.output!)))
-      .on('error', reject)
+      .pipe(createWriteStream(output))
+      .on('error', rej)
       .once('close', (e: Error) => {
         if (e) {
-          reject(e)
+          rej(e)
         } else if (compiler.output) {
-          const output = compiler.output
-          const mode = statSync(output).mode | 0o111
+          const output = compiler.output,
+            mode = statSync(output).mode | 0o111,
+            inputFileLogOutput = relative(
+              process.cwd(),
+              resolve(compiler.options.cwd, compiler.entrypoint || compiler.options.input)
+            ),
+            outputFileLogOutput = relative(process.cwd(), output)
+
           chmodSync(output, mode.toString(8).slice(-3))
-          const inputFile = relative(process.cwd(), compiler.options.input)
-          const outputFile = relative(process.cwd(), output)
           step.log(
             `Entry: '${
-              compiler.stdinUsed ? (compiler.options.mangle ? STDIN_FLAG : '[none]') : inputFile
-            }' written to: ${outputFile}`
+              compiler.stdinUsed
+                ? compiler.options.mangle
+                  ? STDIN_FLAG
+                  : '[none]'
+                : inputFileLogOutput
+            }' written to: ${outputFileLogOutput}`
           )
-          resolve(compiler.quit())
+          compiler.quit()
+          res(output)
         }
       })
   })

src/steps/download.ts

@@ -3,7 +3,6 @@ import { pathExistsAsync } from '../util'
 import { LogStep } from '../logger'
 import { IncomingMessage } from 'http'
 import { NexeCompiler, NexeError } from '../compiler'
-import { getLatestGitRelease } from '../releases'
 import { dirname } from 'path'
 
 function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
@@ -12,7 +11,7 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
     .on('response', (res: IncomingMessage) => {
       const total = +res.headers['content-length']!
       let current = 0
-      res.on('data', data => {
+      res.on('data', (data) => {
         current += data.length
         setText((current / total) * 100)
         if (current === total) {
@@ -24,37 +23,28 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
 }
 
 async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
-  let downloadOptions = compiler.options.downloadOptions
-  const target = compiler.target
+  const { target, remoteAsset } = compiler,
+    filename = compiler.getNodeExecutableLocation(target)
 
-  if (compiler.options.ghToken) {
-    downloadOptions = Object.assign({}, downloadOptions)
-    downloadOptions.headers = Object.assign({}, downloadOptions.headers, {
-      Authorization: 'token ' + compiler.options.ghToken
-    })
+  try {
+    await download(remoteAsset, dirname(filename), compiler.options.downloadOptions).on(
+      'response',
+      (res: IncomingMessage) => {
+        const total = +res.headers['content-length']!
+        let current = 0
+        res.on('data', (data) => {
+          current += data.length
+          step!.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
+        })
+      }
+    )
+  } catch (e) {
+    if (e.statusCode === 404) {
+      throw new NexeError(`${remoteAsset} is not available, create it using the --build flag`)
+    } else {
+      throw new NexeError('Error downloading prebuilt binary: ' + e)
+    }
   }
-
-  const githubRelease = await getLatestGitRelease(downloadOptions)
-  const assetName = target.toString()
-  const asset = githubRelease.assets.find(x => x.name === assetName)
-
-  if (!asset) {
-    throw new NexeError(`${assetName} not available, create it using the --build flag`)
-  }
-  const filename = compiler.getNodeExecutableLocation(target)
-
-  await download(
-    asset.browser_download_url,
-    dirname(filename),
-    compiler.options.downloadOptions
-  ).on('response', (res: IncomingMessage) => {
-    const total = +res.headers['content-length']!
-    let current = 0
-    res.on('data', data => {
-      current += data.length
-      step!.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
-    })
-  })
 }
 
 /**
@@ -66,12 +56,12 @@ export default async function downloadNode(compiler: NexeCompiler, next: () => P
   const { src, log, target } = compiler,
     { version } = target,
     { sourceUrl, downloadOptions, build } = compiler.options,
-    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
-  const step = log.step(
-    `Downloading ${build ? '' : 'pre-built '}Node.js${build ? `source from: ${url}` : ''}`
-  )
-  const exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target)
-  const downloadExists = await pathExistsAsync(build ? src : exeLocation)
+    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
+    step = log.step(
+      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? `source from: ${url}` : ''}`
+    ),
+    exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target),
+    downloadExists = await pathExistsAsync(build ? src : exeLocation)
 
   if (downloadExists) {
     step.log('Already downloaded...')

src/steps/resource.ts

@@ -1,22 +1,25 @@
-import { isDirectoryAsync, each } from '../util'
-import globs from 'globby'
+import { each } from '../util'
+import * as globs from 'globby'
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'
 
 export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
-  const { cwd } = compiler.options
-  if (!compiler.options.resources.length) {
+  const { cwd, resources } = compiler.options
+  if (!resources.length) {
     return next()
   }
   const step = compiler.log.step('Bundling Resources...')
   let count = 0
-  await each(globs(compiler.options.resources, { cwd }), async file => {
-    if (await isDirectoryAsync(file)) {
-      return
-    }
+
+  // workaround for https://github.com/sindresorhus/globby/issues/127
+  // and https://github.com/mrmlnc/fast-glob#pattern-syntax
+  const resourcesWithForwardSlashes = resources.map((r) => r.replace(/\\/g, '/'))
+
+  await each(globs(resourcesWithForwardSlashes, { cwd, onlyFiles: true }), async (file) => {
     count++
     step.log(`Including file: ${file}`)
-    await compiler.addResource(file)
+    await compiler.addResource(resolve(cwd, file))
   })
-  step.log(`Included ${count} file(s). ${(compiler.resourceSize / 1e6).toFixed(3)} MB`)
+  step.log(`Included ${count} file(s)`)
   return next()
 }

src/steps/shim.ts

@@ -1,12 +1,15 @@
 import { NexeCompiler } from '../compiler'
 import { wrap } from '../util'
 
-export default function(compiler: NexeCompiler, next: () => Promise<void>) {
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
+  await next()
   compiler.shims.push(
     wrap(
-      `process.__nexe = ${JSON.stringify(compiler.binaryConfiguration)};\n` +
+      '' +
         '{{replace:lib/fs/patch.js}}' +
-        '\nshimFs(process.__nexe)'
+        '\nshimFs(process.__nexe)' +
+        `\n${compiler.options.fs ? '' : 'restoreFs()'}`
+      //TODO support only restoring specific methods
     )
   )
   compiler.shims.push(
@@ -22,10 +25,12 @@ export default function(compiler: NexeCompiler, next: () => Promise<void>) {
   compiler.shims.push(
     wrap(`
       if (!process.send) {
-        process.argv.splice(1,0, require.resolve(${JSON.stringify(compiler.entrypoint)}))  
+        const path = require('path')
+        const entry = path.resolve(path.dirname(process.execPath),${JSON.stringify(
+          compiler.entrypoint
+        )})
+        process.argv.splice(1,0, entry)
       }
     `)
   )
-
-  return next()
 }

src/target.ts

@@ -1,8 +1,8 @@
 export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = 'x86' | 'x64' | 'arm7l' | 'arm6l' | 'arm64'
+export type NodeArch = 'x86' | 'x64' | 'arm' | 'arm64'
 
 const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ['x86', 'x64', 'arm7l', 'arm6l', 'arm64']
+  architectures: NodeArch[] = ['x86', 'x64', 'arm', 'arm64']
 
 export { platforms, architectures }
 
@@ -21,21 +21,21 @@ const prettyPlatform: { [key: string]: NodePlatform } = {
   mac: 'mac',
   linux: 'linux',
   static: 'alpine',
-  alpine: 'alpine'
+  alpine: 'alpine',
 }
 
 const prettyArch: { [key: string]: NodeArch } = {
   x86: 'x86',
-  arm6: 'arm6l',
+  arm6: 'arm',
   arm64: 'arm64',
-  arm6l: 'arm6l',
-  arm: 'arm7l',
-  arm7: 'arm7l',
-  arm7l: 'arm7l',
+  arm6l: 'arm',
+  arm: 'arm',
+  arm7: 'arm',
+  arm7l: 'arm',
   amd64: 'x64',
   ia32: 'x86',
   x32: 'x86',
-  x64: 'x64'
+  x64: 'x64',
 }
 
 function isVersion(x: string) {
@@ -80,7 +80,7 @@ export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget
   target
     .toLowerCase()
     .split('-')
-    .forEach(x => {
+    .forEach((x) => {
       if (isVersion(x)) {
         version = x.replace(/v/g, '')
       }

src/util.ts

@@ -1,9 +1,9 @@
 import { readFile, writeFile, stat } from 'fs'
 import { execFile } from 'child_process'
-import pify = require('pify')
+import { promisify } from 'util'
 import rimraf = require('rimraf')
 
-const rimrafAsync = pify(rimraf)
+const rimrafAsync = promisify(rimraf)
 export const STDIN_FLAG = '[stdin]'
 
 export async function each<T>(
@@ -42,10 +42,10 @@ const bound: MethodDecorator = function bound<T>(
       Object.defineProperty(this, propertyKey as string, {
         configurable,
         value,
-        writable: true
+        writable: true,
       })
       return value
-    }
+    },
   }
 }
 
@@ -64,21 +64,21 @@ export interface ReadFileAsync {
   (path: string, encoding: string): Promise<string>
 }
 
-const readFileAsync = pify(readFile)
-const writeFileAsync = pify(writeFile)
-const statAsync = pify(stat)
-const execFileAsync = pify(execFile)
+const readFileAsync = promisify(readFile)
+const writeFileAsync = promisify(writeFile)
+const statAsync = promisify(stat)
+const execFileAsync = promisify(execFile)
 const isWindows = process.platform === 'win32'
 
 function pathExistsAsync(path: string) {
   return statAsync(path)
-    .then(x => true)
+    .then((x) => true)
     .catch(falseOnEnoent)
 }
 
 function isDirectoryAsync(path: string) {
   return statAsync(path)
-    .then(x => x.isDirectory())
+    .then((x) => x.isDirectory())
     .catch(falseOnEnoent)
 }
 /**
@@ -109,5 +109,5 @@ export {
   readFileAsync,
   pathExistsAsync,
   isDirectoryAsync,
-  writeFileAsync
+  writeFileAsync,
 }

tasks/asset-compile.ts

@@ -1,106 +0,0 @@
-import * as nexe from '../lib/nexe'
-import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
-import * as ci from './ci'
-import { runDockerBuild } from './docker'
-import { getTarget, targetsEqual } from '../lib/target'
-import { pathExistsAsync, readFileAsync, execFileAsync } from '../lib/util'
-import got = require('got')
-
-const env = process.env,
-  branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
-  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isWindows = Boolean(env.APPVEYOR),
-  isPullRequest =
-    Boolean(env.CIRCLE_PR_NUMBER) ||
-    Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) ||
-    Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = {
-    Authorization: 'token ' + env.GITHUB_TOKEN,
-    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-  }
-
-if (require.main === module) {
-  if (!isPullRequest) {
-    build().catch(x => {
-      console.error(x)
-      process.exit(1)
-    })
-  }
-}
-
-async function build() {
-  if (isScheduled) {
-    const releases = await getUnBuiltReleases({ headers })
-    if (!releases.length) {
-      return
-    }
-    const windowsBuild = releases.find(x => x.platform === 'windows')
-    const macBuild = releases.find(x => x.platform === 'mac')
-    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')
-
-    if (linuxOrAlpine) {
-      await ci.triggerDockerBuild(linuxOrAlpine, branchName)
-    }
-    if (macBuild) {
-      await ci.triggerMacBuild(macBuild, branchName)
-    }
-    if (windowsBuild) {
-      await ci.triggerWindowsBuild(windowsBuild)
-    }
-  }
-
-  if (env.NEXE_VERSION) {
-    const target = getTarget(env.NEXE_VERSION),
-      output = isWindows ? './out.exe' : './out',
-      options = {
-        empty: true,
-        build: true,
-        target,
-        output
-      }
-    console.log('Building: ', target)
-    const stop = keepalive()
-    if (['arm7l', 'arm6l', 'arm64', 'alpine'].includes(target.platform)) {
-      await runDockerBuild(target)
-    } else {
-      await nexe.compile(options)
-    }
-    stop()
-
-    if (await pathExistsAsync(output)) {
-      await assertNexeBinary(output)
-      const gitRelease = await getLatestGitRelease({ headers })
-      const unbuiltReleases = await getUnBuiltReleases({ headers })
-      if (!unbuiltReleases.some(x => targetsEqual(x, target))) {
-        console.log(`${target} already uploaded.`)
-        return
-      }
-      await got(gitRelease.upload_url.split('{')[0], {
-        query: { name: target.toString() },
-        body: await readFileAsync(output),
-        headers: {
-          ...headers,
-          'Content-Type': 'application/octet-stream'
-        }
-      }).catch(reason => {
-        console.log(reason && reason.response && reason.response.body)
-        throw reason
-      })
-      console.log(target + ' uploaded.')
-    }
-  }
-}
-
-function keepalive() {
-  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
-  return () => clearInterval(keepalive)
-}
-
-function assertNexeBinary(file: string) {
-  return execFileAsync(file).catch(e => {
-    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
-      return
-    }
-    throw e
-  })
-}

tasks/build.ts

@@ -0,0 +1,116 @@
+import * as nexe from '../lib/nexe'
+import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
+import { runDockerBuild } from './docker'
+import { getTarget, targetsEqual, NexeTarget } from '../lib/target'
+import { pathExistsAsync, readFileAsync, execFileAsync, semverGt } from '../lib/util'
+import got from 'got'
+import { cpus } from 'os'
+
+const env = process.env,
+  isPullRequest = env.BUILD_REASON === 'PullRequest',
+  isWindows = process.platform === 'win32',
+  isLinux = process.platform === 'linux',
+  buildHost = env.AGENT_JOBNAME || (isWindows && 'windows_2017_2015') || '',
+  isMac = process.platform === 'darwin',
+  headers = {
+    Authorization: 'token ' + env.GITHUB_TOKEN,
+    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)',
+  }
+
+if (require.main === module) {
+  if (!isPullRequest) {
+    build().catch((x) => {
+      console.error(x)
+      process.exit(1)
+    })
+  }
+}
+
+async function build() {
+  const releases = await getUnBuiltReleases({ headers })
+  if (!releases.length) {
+    return
+  }
+  const windowsBuild = releases.find((x) => x.platform === 'windows'),
+    macBuild = releases.find((x) => x.platform === 'mac'),
+    linux = releases.find((x) => x.platform === 'linux'),
+    alpine = releases.find((x) => x.platform === 'alpine')
+
+  let target: NexeTarget | undefined
+
+  if (env.NEXE_VERSION) target = getTarget(env.NEXE_VERSION)
+  else if (isWindows) target = windowsBuild
+  else if (isMac) target = macBuild
+  else if (isLinux) target = linux
+  if (buildHost.includes('alpine')) target = alpine
+
+  if (!target) {
+    return console.log('Nothing to build...')
+  }
+
+  if (isWindows && buildHost.includes('2017') && !semverGt(target.version, '9.99.99')) {
+    return console.log(`Not building ${target} on this host...`)
+  }
+  if (isWindows && buildHost.includes('2015') && semverGt(target.version, '9.99.99')) {
+    return console.log(`Not building ${target} on this host...`)
+  }
+
+  const output = isWindows ? './out.exe' : './out',
+    options = {
+      mangle: false,
+      build: true,
+      verbose: Boolean(env.NEXE_VERBOSE!),
+      target,
+      make: ['-j' + cpus().length],
+      output,
+    }
+  console.log('Building: ' + target + ' on ' + buildHost)
+  const stop = keepalive()
+
+  if (
+    [/*'arm7l', 'arm6l', 'arm64', */ 'alpine'].includes(target.platform) &&
+    buildHost.includes('alpine')
+  ) {
+    await runDockerBuild(target)
+  } else {
+    await nexe.compile(options)
+  }
+  stop()
+  if (await pathExistsAsync(output)) {
+    await assertNexeBinary(output)
+    const gitRelease = await getLatestGitRelease({ headers }),
+      unbuiltReleases = await getUnBuiltReleases({ headers })
+    if (!unbuiltReleases.some((x) => targetsEqual(x, target!))) {
+      console.log(`${target} already uploaded.`)
+      process.exit(0)
+      return
+    }
+    await got(gitRelease.upload_url.split('{')[0], {
+      searchParams: { name: target.toString() },
+      body: await readFileAsync(output),
+      headers: {
+        ...headers,
+        'Content-Type': 'application/octet-stream',
+      },
+    }).catch((reason) => {
+      console.log(reason && reason.response && reason.response.body)
+      throw reason
+    })
+    console.log(target + ' uploaded.')
+    process.exit(0)
+  }
+}
+
+function keepalive() {
+  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
+  return () => clearInterval(keepalive)
+}
+
+function assertNexeBinary(file: string) {
+  return execFileAsync(file).catch((e) => {
+    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
+      return
+    }
+    throw e
+  })
+}

tasks/ci.ts

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

tasks/docker.ts

@@ -6,10 +6,10 @@ import { appendFileSync } from 'fs'
 
 function alpine(target: NexeTarget) {
   return `
-FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.4
+FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.12
 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
+ENV NEXE_VERSION=latest
 WORKDIR /
 
 RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
@@ -20,19 +20,20 @@ RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.t
   paxctl -cm /usr/bin/node
 
 RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
-  npm install -g nexe@\${NEXE_VERSION} && \
-  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out --enableStdIn=false
+  npm install -g nexe@\${NEXE_VERSION}
+RUN echo "console.log('hello world')" >> index.js && \
+  nexe --build --no-mangle --temp /nexe_temp -c="--fully-static" -o out
 `.trim()
 }
 
 function arm(target: NexeTarget) {
   return `
 FROM hypriot/rpi-node
-ENV NEXE_VERSION=beta
+ENV NEXE_VERSION=latest
 WORKDIR /
 
 RUN yarn global add nexe@\${NEXE_VERSION} && \
-  nexe --build --empty -o out -t ${target.version}
+  nexe --build --no-mangle -o out -t ${target.version}
 `.trim()
 }
 
@@ -45,10 +46,10 @@ export async function runDockerBuild(target: NexeTarget) {
   let output: any = []
 
   try {
-    output.push(await execa.shell(`docker build -t nexe-docker .`))
-    output.push(await execa.shell(`docker run -d --name nexe nexe-docker sh`))
-    output.push(await execa.shell(`docker cp nexe:/out out`))
-    output.push(await execa.shell(`docker rm nexe`))
+    output.push(await execa(`docker build -t nexe-docker .`, { shell: true }))
+    output.push(await execa(`docker run -d --name nexe nexe-docker sh`, { shell: true }))
+    output.push(await execa(`docker cp nexe:/out out`, { shell: true }))
+    output.push(await execa(`docker rm nexe`, { shell: true }))
   } catch (e) {
     console.log('Error running docker')
     appendFileSync(outFilename, e.message)
@@ -57,16 +58,11 @@ export async function runDockerBuild(target: NexeTarget) {
       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))
   }
 }

test/options.spec.ts

@@ -10,9 +10,13 @@ describe('options', () => {
       const options = normalizeOptions()
       expect(options.cwd).to.equal(process.cwd())
     })
-    it('should use the main module in a package directory', () => {
+    it('should use the main module in a package directory (if not in a TTY)', () => {
       const options = normalizeOptions()
-      expect(options.input).to.equal(path.resolve('./index.js'))
+      if (!process.stdin.isTTY) {
+        expect(options.input).to.equal('[stdin]')
+      } else {
+        expect(options.input).to.equal(path.resolve('./index.js'))
+      }
     })
     it('should resolve relative paths for input', () => {
       const options = normalizeOptions({ input: 'test/fixture/entry.js' })
@@ -35,6 +39,26 @@ describe('options', () => {
       expect(options.output).to.equal(path.resolve(cwd, `abc${ext}`))
     })
   })
+
+  describe('remote', () => {
+    it('should use default remote', () => {
+      const options = normalizeOptions({})
+      expect(options.remote).to.equal('https://github.com/nexe/nexe/releases/download/v3.3.3/')
+    })
+    it('should append trailing slash to third-party remote if necessary', () => {
+      const options = normalizeOptions({
+        remote: 'https://sitejs.org/nexe'
+      })
+      expect(options.remote).to.equal('https://sitejs.org/nexe/')
+    })
+    it('should not append trailing slash to third-party remote that already has one', () => {
+      const options = normalizeOptions({
+        remote: 'https://sitejs.org/nexe/'
+      })
+      expect(options.remote).to.equal('https://sitejs.org/nexe/')
+    })
+  })
+
   describe('output', () => {
     it('should work', () => {
       const options = normalizeOptions({

tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target":"es5",
+    "target":"es2015",
     "skipLibCheck": true,
     "experimentalDecorators": true,
     "lib": ["es2018"],