Update src/steps/download.ts

Co-authored-by: Jared Allard <jaredallard@users.noreply.github.com>

.editorconfig

@@ -4,5 +4,5 @@ end_of_line = lf
 charset = utf-8
 indent_style = space
 indent_size = 2
-trim_trailing_whitespace=true
+trim_trailing_whitespace = true
 insert_final_newline = true

.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**:

.github/workflows/auto-close-no-response.yml

@@ -0,0 +1,21 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    # 9AM Central
+    - cron: '0 14 * * *'
+
+jobs:
+  noResponse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          closeComment: 'Closed awaiting response from OP, please open a new issue with the requested information and/or examples'
+          daysUntilClose: 21
+          responseRequiredLabel: more-information-needed

.gitignore

@@ -1,9 +1,12 @@
 .DS_Store
 temp/
 coverage
+nexe
 node_modules
 *.log
 *.exe
+*.bin
+!winsw.exe
 .idea
 .nexe
 lib

.vscode/extensions.json

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

.vscode/settings.json

@@ -1,6 +1,18 @@
 {
-  "typescript.tsdk": "./node_modules/typescript/lib",
+  "tslint.enable": true,
-  "prettier.semi": false,
+  "tslint.run": "onType",
-  "prettier.singleQuote": true,
+  "tslint.autoFixOnSave": true,
-  "prettier.typescriptEnable": ["typescript"]
+  "files.exclude": {
+    "**/.git": true,
+    "**/.svn": true,
+    "**/.hg": true,
+    "**/CVS": true,
+    "**/.DS_Store": true
+  },
+  "search.exclude": {
+    "lib/**/*": true,
+    "**/node_modules": true,
+    "**/bower_components": true
+  },
+  "typescript.tsdk": "node_modules\\typescript\\lib"
 }

CHANGELOG.md

@@ -5,9 +5,9 @@
 Nexe 2.0 is a rewrite to enable some new features. These include:
   * Quick Builds!
   * Userland build patches
-  * New Resource access
+  * Resource storage/access rewrite
-  * stdin and stdout interfaces
+  * stdin interface
-  * Opt-in bundling
+  * Optional, pluggable bundling
 
 ### Breaking Changes
   * New options -- Please see the [readme](README.md#options)

LICENSE

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

README.md

@@ -1,22 +1,24 @@
+
 <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/jaredallard/nexe"><img src="https://img.shields.io/circleci/project/jaredallard/nexe.svg" alt="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>
+  <a href="https://discord.gg/2qTH52zNcZ"><img src="https://discordapp.com/api/guilds/814334925049561168/widget.png?style=shield"></a>
 </p>
 
-<p align="center"><code>npm i nexe@beta -g</code></p>
+<p align="center">Install:&nbsp<code>npm i nexe -g</code></p>
 <p align="center">Nexe is a command-line utility that compiles your Node.js application into a single executable file.</p>
 
 <p align="center">
-  <img src="https://cloud.githubusercontent.com/assets/5818726/26533446/ce19ee5a-43de-11e7-9540-caf7ebd93370.gif"/>
+  <img src="https://user-images.githubusercontent.com/5818726/30999006-df7e0ae0-a497-11e7-96db-9ce87ae67b34.gif"/>
 </p>
 
 ## Motivation and Features
 
-- Supports production ready, ([securable](#security)) builds
+- Self contained applications
 - Ability to run multiple applications with *different* node.js runtimes.
 - Distribute binaries without needing node / npm.
 - Idempotent builds
@@ -25,43 +27,72 @@
 - Flexible build pipeline
 - Cross platform builds
 
-## Usage (Beta)
+## Usage
 
-*Note: V2 API is still subject to change. * For v1 see [V1-EOL](https://github.com/nexe/nexe/tree/V1-EOL)
+- Application entrypoint:
 
-- Existing application bundle:
+  `nexe my-app.js`
-
-    `nexe -i ./my-app-bundle.js -o ./my-app.exe`
 
 - stdin interface
 
-  `rollup -c | nexe --resource ./public/**/* -o my-app.exe`
+  `rollup -c | nexe --resource "./public/**/*" -o my-app.exe`
 
 For more CLI options see: `nexe --help`
 
-## Including Additional Resources
+### Examples
 
-Additional resources can be added to the binary by passing `-r glob/pattern/**/*`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`
+- `nexe server.js -r "public/**/*.html"`
+- `nexe --build`
+- `nexe -t x86-8.0.0`
 
-## Compiling Node
+## Resources
 
-By default `nexe` will attempt to download a pre-built executable. However, some users may want to customize the way node is built, either by changing the flags, providing a different icon, or different executable details. These options are supported out of the box, and subsequent builds with compatible options will result in instant build times.
+Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`.
 
-Nexe also exposes its patching pipeline to the user. This allows the application of simple patching of node sources prior to compilation.
+## Compiling the nexe Executable
+
+By default `nexe` will attempt to download a pre-built executable. These are listed on the [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 3; you can create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486) or use the `--python` parameter (e.g. `nexe --build --python=$(which python3)`).
+
+### Linux and macOS
+[Prerequisites & details](https://github.com/nodejs/node/blob/master/BUILDING.md#unix-and-macos)
+
+### Windows
+
+The fastest and most reliable way to get started is simply to run the commands below. If you'd rather read the details or perform a manual install of the prerequisites, [you can find that here](https://github.com/nodejs/node/blob/master/BUILDING.md#windows).
+
+The instructions below are the fastest and most reliable method.
+Run the following sets of commands with PowerShell (running as Administrator).
+
+**Install all required build tools (and dependencies):**
+```
+Set-ExecutionPolicy Unrestricted -Force
+iex ((New-Object System.Net.WebClient).DownloadString('https://boxstarter.org/bootstrapper.ps1'))
+get-boxstarter -Force
+Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter -DisableReboots
+```
+
+**Set config:**
+```
+npm config set msvs_version 2019
+npm config set python python3.8
+```
+Where `2019` is the version of Visual Studio you have (if you have it).
+
+**Notes:**
+- The above works and has been tested with node.js `14.5.4` and `15.8.0`
+- Python 3 and Python 2 can coexist and `nexe` will still work, considering the `set config` area above
+- Don't use `npm install windows-build-tools` unless you're having some type of issue, because the above commands configures and installs the latest/preferred too.
 
 ## Node.js API
 
-Using Nexe Programatically
-
 #### Example
 
-
 ```javascript
-const nexe = require('nexe')
+const { compile } = require('nexe')
 
-nexe.compile({
+compile({
-  input: './my-app-bundle.js'
+  input: './my-app.js',
-  output: './my-app.exe'
+  build: true, //required to use patches
   patches: [
     async (compiler, next) => {
       await compiler.setFileContentsAsync(
@@ -75,88 +106,127 @@ nexe.compile({
   console.log('success')
 })
 ```
+## NexeOptions
 
-### `options`
+### `options: object`
 
- - #### `build: boolean`
-    - Build node from source (required in beta)
  - #### `input: string`
     - Input bundle file path
     - default: stdin or the current directory's main file (package.json)
  - #### `output: string`
     - Output executable file path
     - default: same as `name` with an OS specific extension.
- - #### `target: string`
+ - #### `target: string | object`
-    - Dash seperated platform-architecture-version. e.g. `'win32-ia32-6.10.3'`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-10.13.0'`
-    - default: `[process.platform, process.arch, process.version.slice(1)].join('-')`
+      - each segment is optional, and will be merged with the current environment
-- #### `bundle: string`
+      - Examples: ([full list](https://github.com/nexe/nexe/releases))
-    - Path to a custom bundling function. When executed it should either return a fusebox producer, or a string.
+        - `'win32-x86-10.13.0`
-    - If it is a string it will be required and the export `nexeBundle` will be used
+        - `{ platform: 'alpine' }`
-    - Defaults to the internal fuse-box configuration
+        - `darwin-10.13.0`
+        - `linux-x64`
+        - `macos-10.13.0`
+
+        See [test/target.spec.ts](test/target.spec.ts)
+    - If the [`build`](#build-boolean) flag is set, the platform portion of the target is ignored.
+    - default: `process`
+- #### `bundle: string | boolean`
+    - If a string is provided it must be a valid relative module path
+    and should provide an export with the following signature:
+    ```typescript
+    export function createBundle (options: NexeOptions): Promise<string>
+    ```
+    - default: true
  - #### `name: string`
     - Module friendly name of the application
     - default: basename of the input file, or `nexe_${Date.now()}`
- - #### `version: string`
+ - #### `cwd: string`
-    - The Node version you're building for
+    - Directory nexe will operate on as though it is the cwd
-    - default: `process.version.slice(1)`
+    - 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.
+    - default: `null`
+ - #### `asset: string`
+    - Provide a pre-built nexe binary asset, this is a file path is resolved relative to cwd.
  - #### `python: string`
-    - On Linux this is the path pointing to your python2 executable
+    - On Linux this is the path pointing to your python3 executable
     - On Windows this is the directory where `python` can be accessed
     - default: `null`
- - #### `flags: Array<string>`
+ - #### `flags: string[]`
     - Array of node runtime flags to build node with.
     - Example: `['--expose-gc']`
     - default: `[]`
- - #### `configure: Array<string>`
+ - #### `configure: string[]`
     - Array of arguments for the node build configure step
     - Example: `['--with-dtrace', '--dest-cpu=x64']`
     - default: `[]`
- - #### `make: Array<string>`
+ - #### `make: string[]`
     - Array of arguments for the node build make step
     - default: `[]`
- - #### `vcBuild: Array<string>`
+ - #### `vcBuild: string[]`
-    - Array of arguments for the node build step on windows
+    - Options for windows build
     - default: `['nosign', 'release']`
  - #### `snapshot: string`
     - path to a file to be used as the warmup snapshot for the build
     - default: `null`
- - #### `resources: Array<string>`
+ - #### `resources: string[]`
     - Array of globs with files to include in the build
     - Example: `['./public/**/*']`
     - default: `[]`
  - #### `temp: string`
     - Path to use for storing nexe's build files
     - Override in the env with `NEXE_TEMP`
-    - default: `./.nexe` in the cwd
+    - default: `~/.nexe`
  - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only).
+    - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
  - #### `rc: object`
     - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example: `{ CompanyName: "ACME Corp" }`
+    - Example (keys may vary depending on the version. Reference the file linked above):
+      ```javascript
+        {
+          CompanyName: "ACME Corp",
+          PRODUCTVERSION: "17,3,0,0",
+          FILEVERSION: "1,2,3,4"
+          ...
+        }
+      ```
     - default: `{}`
  - #### `clean: boolean`
-    - If included, nexe will remove temporary files for accompanying configuration and exit
+    - If included, nexe will remove temporary files for the accompanying configuration and exit
  - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working)
+    - Enable the original Node CLI (will prevent application cli from working).
+    - Node CLI arguments passed via the [NODE_OPTIONS](https://nodejs.org/api/cli.html#cli_node_options_options) environment
+      variable will still be processed. NODE_OPTIONS support can be disabled with the `--without-node-options` configure flag.
     - default: `false`
+  - #### `fakeArgv: boolean`
+    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`.
+ - #### `ghToken: string`
+    - Provide a Github Token for accessing nexe releases
+    - This is usually needed in CI environments
+    - default: `process.env.GITHUB_TOKEN`
  - #### `sourceUrl: string`
-    - Provide an alternate url for the node source. Should be a `.tar.gz`
+    - Provide an alternate url for the node source code
+    - Note: temporary files will still be created for this under the specified version
  - #### `loglevel: string`
     - Set the loglevel, info, silent, or verbose
     - default: `'info'`
- - #### `padding`
+ - #### `patches: NexePatch[]`
-    - Advanced option for controlling the size available in the executable.
-    - It must be larger than the bundle + resources in bytes
-    - default: 3, 6, 9, 16, 25, or 40 MB sizes are selected automatically.
- - #### `patches: Array<NexePatch>`
     - Userland patches for patching or modifying node source
     - default: `[]`
+ - #### `plugins: NexePatch[]`
+    - Userland plugins for modifying nexe executable behavior
+    - default: `[]`
 
 ### `NexePatch: (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>`
 
-A patch is just a middleware function that takes two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior.
+Patches and Plugins are just a middleware functions that take two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior. Patches also require that [`--build`](#build-boolean) be set, while plugins do not.
 
-For examples, see the built in patches: [src/patches](src/patches)
+For examples, see the built in patches: [src/patches](src/patches).
 
 ### `NexeCompiler`
 
@@ -164,33 +234,47 @@ For examples, see the built in patches: [src/patches](src/patches)
     - Quickly set a file's contents within the downloaded Node.js source.
  - `replaceInFileAsync(filename: string, ...replaceArgs): Promise<void>`
     - 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<SourceFile>`
+ - `readFileAsync(filename: string): Promise<NexeFile>`
     - Access (or create) a file within the downloaded Node.js source.
- - `files: Array<SourceFile>`
+ - `addResource(filename: string, contents: Buffer): Promise<void>`
-    - The cache of currently read, modified, or created files within the downloaded Node.js source.
+    - 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.
 
-#### `SourceFile`
+#### `NexeFile`
   - `contents: string`
+  - `absPath: string`
   - `filename: string`
 
-Any modifications made to `SourceFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.
+Any modifications made to `NexeFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.
 
-### Native Modules
+## Native Modules
 
-Nexe has a plugin built for use with [fuse-box](http://fuse-box.org) > 2.2.1. This plugin currently supports modules that require `.node` files and those that use the `bindings` module.
+In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.
-Take a look at the [example](examples/native-build/build.js)
 
-Future: Implement support `node-pre-gyp#find`.
+## Troubleshooting
 
-## Security
+`Error: Entry file "" not found!` means you need to provide `nexe` with input. Either use `-i` or pipe data to it.
-A common use case for Nexe is production deployment. When distributing executables it is important to [sign](https://en.wikipedia.org/wiki/Code_signing) them before distributing. Nexe was designed specifically to not mangle the binary it produces, this allows the checksum and signature of the size and location offsets to be maintained through the code signing process.
 
-## Maintainers
+`Error: https://github.com/nexe/nexe/releases/download/v3.3.3/windows-x64-15.8.0 is not available, create it using the --build flag` or similar message means that it either:
+- You are having networking issues such as the download being blocked
+- You should specify the target so `nexe` knows what version of the executable to use.
+	- See the [releases page](https://github.com/nexe/nexe/releases) to find the executable's version number
+	- Example
+		- `nexe -i "app.js" -r "public/**/*.html" -o "dist/myApp.exe" -t x64-14.15.3`
+		- where `-i` specifies the input, `-r` specifies resources to embed, `-o` specifies the output, `-t` specifies the target.
+	- Alternatively you can compile the executable yourself, see that section for details
 
-[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Christopher Karper](https://avatars.githubusercontent.com/u/653156?s=130)](https://github.com/ckarper) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
+## Contributing
----|---|---|---
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |
 
-### Former
+Building
+```
+$ git clone git@github.com:nexe/nexe.git
+$ cd nexe
+$ npm i && npm run build
+```
 
-- [Craig Condon](http://crcn.codes/)
+Testing
+```
+$ npm test
+```

azure-pipelines.yml

@@ -0,0 +1,73 @@
+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: 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: |
+      choco 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)
+  - script: npm run test:integration
+    displayName: Test built artefact
+    env:
+      NEXE_VERBOSE: $(NEXE_VERBOSE)
+      BUILD: ''

examples/express-app/index.js

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

examples/express-app/package-lock.json

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

examples/express-app/package.json

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

examples/express-app/public/index.html

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

examples/native-build/build.js

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

examples/native-build/index.js

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

examples/native-build/package.json

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

index.js

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

issue_template.md

@@ -1,22 +0,0 @@
-This is a
- - [ ] Bug Report
- - [ ] Feature Request
- - [ ] Other
-
-<br/>
-If this is a bug report, What are the steps to reproduce?
-
-```
-//provide configuration here
-```
-
-<br/><br/>
-Please also provide: 
-
-- Platform(OS/Version):
-- Host Node Version:
-- Target Node Version:
-- Nexe version:
-- Python Version:
-
- 

package.json

@@ -2,17 +2,24 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "2.0.0-beta.3",
+  "version": "5.0.0-beta.1",
   "contributors": [
     "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
     "Jared Allard <jaredallard@outlook.com>",
     "Caleb Boyd <caleb.boyd@hotmail.com>"
   ],
   "scripts": {
-    "prebuild": "rimraf lib && npm run lint",
+    "ci:build": "ts-node tasks/build",
-    "prepublish": "npm run build",
+    "test": "mocha",
-    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
+    "test:integration": "node index.js --target 14.15.3 -i test/integration/index.js -o integration-tests --verbose -r test/integration -r node_modules/ && npm run test:integration:run",
-    "build": "tsc --declaration"
+    "test:integration:run": "run-script-os",
+    "test:integration:run:win32": "integration-tests.exe",
+    "test:integration:run:default": "./integration-tests",
+    "lint": "tslint \"{src,plugins,tasks}/**/*.ts\" --fix",
+    "prepare": "npm run lint && npm run build && npm test",
+    "prebuild": "rimraf lib",
+    "build": "tsc --declaration && tsc -p tasks && webpack",
+    "postbuild": "ts-node tasks/post-build"
   },
   "repository": {
     "type": "git",
@@ -21,38 +28,65 @@
   "files": [
     "lib"
   ],
+  "typings": "lib/nexe.d.ts",
   "main": "index.js",
   "bin": {
     "nexe": "index.js"
   },
   "engines": {
-    "node": ">=6"
+    "node": ">=10"
+  },
+  "mocha": {
+    "spec": "./test/**/*.spec.ts",
+    "checkLeaks": true,
+    "require": [
+      "ts-node/register"
+    ]
   },
   "dependencies": {
-    "app-builder": "^5.1.0",
+    "@calebboyd/semaphore": "^1.3.1",
-    "bluebird": "^3.5.0",
+    "@yarnpkg/fslib": "^3.0.0-rc.43",
-    "chalk": "^1.1.3",
+    "@yarnpkg/libzip": "^3.0.0-rc.43",
-    "download": "^6.2.0",
+    "app-builder": "^7.0.4",
-    "fuse-box": "^2.2.1",
+    "archiver": "^5.3.1",
-    "globby": "^6.1.0",
+    "caw": "^2.0.1",
-    "memory-fs": "^0.4.1",
+    "chalk": "^2.4.2",
-    "minimist": "^1.2.0",
+    "download": "^8.0.0",
-    "mkdirp": "^0.5.1",
+    "globby": "^11.0.2",
-    "nigel": "^2.0.2",
+    "got": "^12.6.0",
-    "ora": "^1.2.0",
+    "meriyah": "^4.3.5",
-    "rimraf": "^2.6.1",
+    "minimist": "^1.2.8",
-    "tar": "^3.1.3"
+    "mkdirp": "^1.0.4",
+    "multistream": "^4.1.0",
+    "ora": "^3.4.0",
+    "resolve-dependencies": "^6.0.9",
+    "rimraf": "^3.0.2",
+    "run-script-os": "^1.1.6",
+    "webpack-config-prefabs": "0.0.5"
   },
   "devDependencies": {
-    "@types/bluebird": "^3.5.8",
+    "@types/archiver": "^5.3.2",
-    "@types/chalk": "^0.4.31",
+    "@types/chai": "^4",
-    "@types/globby": "^0.6.0",
+    "@types/download": "^8",
-    "@types/minimist": "^1.2.0",
+    "@types/globby": "^9",
-    "@types/mkdirp": "^0.3.29",
+    "@types/lodash": "^4.14.192",
-    "@types/ora": "^0.3.31",
+    "@types/minimist": "^1.2.2",
-    "@types/rimraf": "0.0.28",
+    "@types/mkdirp": "^1.0.2",
-    "mocha": "^3.2.0",
+    "@types/mocha": "^10.0.1",
-    "prettier": "^1.4.4",
+    "@types/multistream": "^4.1.0",
-    "typescript": "^2.4.1"
+    "@types/ora": "^3.2.0",
+    "@types/rimraf": "3.0.2",
+    "@types/semver": "^7.3.13",
+    "chai": "^4.3.7",
+    "execa": "^5.1.1",
+    "lodash": "^4.17.21",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.1",
+    "tslint-config-prettier": "^1.18.0",
+    "tslint-plugin-prettier": "^2.3.0",
+    "typescript": "^5.0.3",
+    "webpack-cli": "^5.0.1"
   }
 }

src/artifacts.ts

@@ -1,62 +0,0 @@
-import { join, dirname } from 'path'
-import { readdir, unlink } from 'fs'
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from './util'
-import { promisify, map } from 'bluebird'
-import * as mkdirp from 'mkdirp'
-import { NexeCompiler } from './compiler'
-
-const mkdirpAsync = promisify(mkdirp)
-const unlinkAsync = (promisify(unlink) as any) as (path: string) => PromiseLike<void>
-const readdirAsync = promisify(readdir)
-
-function readDirAsync(dir: string): PromiseLike<string[]> {
-  return readdirAsync(dir)
-    .map((file: string) => {
-      const path = join(dir, file)
-      return isDirectoryAsync(path).then((x: boolean) => (x ? readDirAsync(path) : path as any))
-    })
-    .reduce((a: string[], b: string[] | string) => a.concat(b), [])
-}
-
-function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, 'utf-8').catch(e => {
-    if (e.code === 'ENOENT') {
-      return ''
-    }
-    throw e
-  })
-}
-
-/**
- * The artifacts step is where source patches are committed, or written as "artifacts"
- * Steps:
- *  - A temporary directory is created in the downloaded source
- *  - On start, any files in that directory are restored into the source tree
- *  - After the patch functions have run, the temporary directory is emptied
- *  - Original versions of sources to be patched are written to the temporary directory
- *  - Finally, The patched files are written into source.
- *
- */
-export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src } = compiler
-  const temp = join(src, 'nexe')
-  await mkdirpAsync(temp)
-  const tmpFiles = await readDirAsync(temp)
-
-  await map(tmpFiles, async path => {
-    return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
-  })
-
-  await next()
-
-  await map(tmpFiles, x => unlinkAsync(x))
-  return map(compiler.files, async file => {
-    const sourceFile = join(src, file.filename)
-    const tempFile = join(temp, file.filename)
-    const fileContents = await maybeReadFileContentsAsync(sourceFile)
-
-    await mkdirpAsync(dirname(tempFile))
-    await writeFileAsync(tempFile, fileContents)
-    await compiler.writeFileAsync(file.filename, file.contents)
-  })
-}

src/bundling/bindings-rewrite.ts

@@ -1,92 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child from 'child_process'
-
-function findNativeModulePath(filePath: string, bindingsArg: string) {
-  const dirname = path.dirname(filePath)
-  const tempFile = Math.random() * 100 + '.js'
-  const tempFilePath = path.join(dirname, tempFile)
-  fs.writeFileSync(
-    tempFilePath,
-    `
-    var bindings = require('bindings');
-    var Module = require('module');
-    var originalRequire = Module.prototype.require;
-    Module.prototype.require = function(path) {
-      const mod = originalRequire.apply(this, arguments);
-      process.stdout.write(path)
-      return mod
-    };
-    bindings('${bindingsArg}')
-  `
-  )
-  //using exec because it can be done sync
-  const nativeFileName = child.execSync('node ' + tempFile, { cwd: dirname }).toString()
-  fs.unlinkSync(tempFilePath)
-  const relativePath = './' + path.relative(dirname, nativeFileName).replace(/\\/g, '/')
-  return relativePath
-}
-/**
- * Traverse all nodes in a file and evaluate usages of the bindings module
- * handles two common cases
- */
-export class BindingsRewrite {
-  private bindingsIdNodes: any[] = []
-  public nativeModulePaths: string[] = []
-  public rewrite = false
-
-  isRequireBindings(node: any) {
-    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
-  }
-
-  onNode(absolutePath: string, node: any, parent: any) {
-    if (node.type === 'CallExpression') {
-      if (this.isRequireBindings(node) && parent.type === 'VariableDeclarator') {
-        /**
-         * const loadBindings = require('bindings');
-         *   -> const loadBindings = String('');
-         */
-        this.bindingsIdNodes.push(parent.id)
-        node.callee.name = 'String'
-        node.arguments[0].value = ''
-        this.rewrite = true
-        return
-      }
-
-      if (this.isRequireBindings(node) && parent.type === 'CallExpression') {
-        /**
-         *const bindings = require('bindings')('native-module')....
-         *  -> const bindings = require('./path/to/native/module.node').....
-         */
-        const bindingsArgNode = parent.arguments[0]
-        if (bindingsArgNode.type === 'Literal') {
-          parent.callee = { type: 'Identifier', name: 'require' }
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-
-      const bindingsInvocationIdx = this.bindingsIdNodes.findIndex(x => node.callee.name === x.name)
-
-      if (this.bindingsIdNodes[bindingsInvocationIdx]) {
-        /**
-         * const bindings = loadBindings('native-module')
-         *   -> const bindings = require('./path/to/native/module.node')
-         */
-        const bindingsIdNode = this.bindingsIdNodes[bindingsInvocationIdx]
-        const bindingsArgNode = node.arguments[0]
-        this.bindingsIdNodes.splice(bindingsInvocationIdx, 1)
-
-        if (bindingsArgNode.type === 'Literal') {
-          node.callee.name = 'require'
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-    }
-  }
-}

src/bundling/fuse.ts

@@ -1,136 +0,0 @@
-import { BindingsRewrite } from './bindings-rewrite'
-import { createHash } from 'crypto'
-import { readFileSync } from 'fs'
-import { dirname, join, basename } from 'path'
-
-function hashName(name: string | Buffer) {
-  return createHash('md5').update(name).digest('hex').toString().slice(0, 8)
-}
-
-export interface FuseBoxFile {
-  info: { absPath: string }
-  contents: string
-  analysis: {
-    dependencies: string[]
-    requiresRegeneration: boolean
-  }
-  loadContents(): void
-  makeAnalysis(
-    parsingOptions?: any,
-    traversalPlugin?: {
-      plugins: Array<{
-        onNode(file: FuseBoxFile, node: any, parent: any): void
-        onEnd(file: FuseBoxFile): void
-      }>
-    }
-  ): void
-}
-
-export interface NativeModulePluginOptions {
-  [key: string]:
-    | {
-        additionalFiles: string[]
-      }
-    | true
-}
-
-export default function(options: NativeModulePluginOptions) {
-  return new NativeModulePlugin(options)
-}
-
-export class NativeModulePlugin {
-  public test: RegExp
-  public limit2Project = false
-  private modules: (keyof NativeModulePluginOptions)[]
-
-  constructor(public options: NativeModulePluginOptions) {
-    this.modules = Object.keys(options)
-    this.test = new RegExp(`node_modules\/(${Object.keys(options).join('|')}).*\.js|\.node$`)
-  }
-
-  init(context: any) {
-    context.allowExtension('.node')
-  }
-
-  transform(file: FuseBoxFile) {
-    file.loadContents()
-
-    if (file.info.absPath.endsWith('.node')) {
-      const contents = readFileSync(file.info.absPath)
-      const module = this.modules.find(x =>
-        Boolean(~file.info.absPath.indexOf(join('node_modules', x)))
-      )!
-      const bindingName = basename(file.info.absPath)
-      const settings = this.options[module]
-      const moduleDir = hashName(contents)
-      file.contents = `
-      var fs=require('fs');var path=require('path');var binding='${contents.toString(
-        'base64'
-      )}';function mkdirp(r,t){t=t||null,r=path.resolve(r);try{fs.mkdirSync(r),t=t||r}catch(c){if("ENOENT"===c.code)t=mkdirp(path.dirname(r),t),mkdirp(r,t);else{var i;try{i=fs.statSync(r)}catch(r){throw c}if(!i.isDirectory())throw c}}return t};`
-
-      if (settings === true) {
-        file.contents += `
-          mkdirp('${moduleDir}');
-          var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
-          require('fs').writeFileSync(bindingPath, Buffer.from(binding, 'base64'))
-          process.dlopen(module, bindingPath)
-        `.trim()
-        return
-      }
-
-      let depth = 0
-      settings.additionalFiles.forEach(file => {
-        let ownDepth = 0
-        file.split('/').forEach(x => x === '..' && ownDepth++)
-        depth = ownDepth > depth ? ownDepth : depth
-      })
-      let segments = [moduleDir]
-      while (depth--) {
-        segments.push(hashName(moduleDir + depth))
-      }
-      segments.push(bindingName)
-
-      file.contents += `
-        var cwd = process.cwd()
-        var bindingFileParts = ${JSON.stringify(segments)};
-        var bindingFile = path.join.apply(path, [cwd].concat(bindingFileParts));
-        mkdirp(path.dirname(bindingFile));
-        fs.writeFileSync(bindingFile, Buffer.from(binding, 'base64'));
-        ${settings.additionalFiles.reduce((code, filename, i) => {
-          const contents = readFileSync(join(dirname(file.info.absPath), filename))
-          return (code += `
-            var file${i} = '${contents.toString('base64')}';
-            var filePath${i} = path.join(cwd, bindingFileParts[0], '${filename
-            .split('../')
-            .join('')}');
-            mkdirp(path.dirname(filePath${i}));
-            fs.writeFileSync(filePath${i}, Buffer.from(file${i}, 'base64'));
-          `)
-        }, '')};
-        process.dlopen(module, bindingFile)
-      `
-      return
-    }
-
-    const bindingsRewrite = new BindingsRewrite()
-    file.makeAnalysis(null, {
-      plugins: [
-        {
-          onNode(file, node, parent) {
-            bindingsRewrite.onNode(file.info.absPath, node, parent)
-          },
-          onEnd(file) {
-            if (bindingsRewrite.rewrite) {
-              const index = file.analysis.dependencies.indexOf('bindings')
-              if (~index) {
-                file.analysis.dependencies.splice(index, 1)
-              }
-              file.analysis.dependencies.push(...bindingsRewrite.nativeModulePaths)
-              file.analysis.requiresRegeneration = true
-            }
-          }
-        }
-      ]
-    })
-  }
-}

src/bundling/nexe-fuse.ts

@@ -1,31 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin } from 'fuse-box'
-import NativeModulePlugin from './fuse'
-
-function bundleProducer(filename: string) {
-  const fuse = FuseBox.init({
-    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
-    homeDir: './',
-    writeBundles: false,
-    target: 'server',
-    plugins: [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
-  })
-  fuse.bundle('nexe').instructions(`> ${filename}`)
-  return fuse.run().then(x => {
-    if (x.bundles.size > 1) {
-      console.log('THROW', x.bundles)
-    }
-    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
-  })
-}
-
-export default function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    return next()
-  }
-
-  if (typeof compiler.options.bundle === 'string') {
-  }
-}

src/cli.ts

@@ -1,73 +0,0 @@
-import { normalize } from 'path'
-import * as Bluebird from 'bluebird'
-import { Readable } from 'stream'
-import { createWriteStream, chmodSync } from 'fs'
-import { readFileAsync, dequote, isWindows } from './util'
-import { NexeCompiler } from './compiler'
-
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
-  return new Bluebird(resolve => {
-    let input = ''
-    stream.setEncoding('utf-8')
-    stream.on('data', (x: string) => {
-      input += x
-    })
-    stream.once('end', () => resolve(dequote(input)))
-    stream.resume && stream.resume()
-  })
-}
-
-/**
- * The "cli" step detects whether the process is in a tty. If it is then the input is read into memory.
- * Otherwise, it is buffered from stdin. If no input options are passed in the tty, the package.json#main file is used.
- * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
- *
- * Configuration:
- *   - compiler.options.input - file path to the input bundle.
- *     - fallbacks: stdin, package.json#main
- *   - compiler.options.output - file path to the output executable.
- *     - fallbacks: stdout, nexe_ + epoch + ext
- *
- * @param {*} compiler
- * @param {*} next
- */
-export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { input, output } = compiler.options
-  const { log } = compiler
-  if (!input && !process.stdin.isTTY) {
-    log.step('Using stdin as input')
-    compiler.input = await readStreamAsync(process.stdin)
-  } else if (input) {
-    log.step(`Using input file as the main module: ${input}`)
-    compiler.input = await readFileAsync(normalize(input), 'utf-8')
-  } else if (!compiler.options.empty) {
-    const bundle = require.resolve(process.cwd())
-    log.step("Using the cwd's main file as the main module")
-    compiler.input = await readFileAsync(bundle, 'utf-8')
-  } else {
-    log.step('Using empty input as the main module')
-    compiler.input = ''
-  }
-
-  compiler.input = compiler.input.trim()
-  await next()
-
-  compiler.output = output || `${compiler.options.name}${isWindows ? '.exe' : ''}`
-  const deliverable = await compiler.compileAsync()
-
-  return new Bluebird((resolve, reject) => {
-    const step = log.step('Writing result to file')
-    deliverable
-      .pipe(createWriteStream(normalize(compiler.output!)))
-      .on('error', reject)
-      .once('close', (e: Error) => {
-        if (e) {
-          reject(e)
-        } else if (compiler.output) {
-          chmodSync(compiler.output, '755')
-          step.log(`Executable written to: ${compiler.output}`)
-          resolve(compiler.quit())
-        }
-      })
-  })
-}

src/compiler.ts

@@ -1,284 +1,328 @@
-import { normalize, join } from 'path'
+import { delimiter, resolve, normalize, join } from 'path'
-import * as Bluebird from 'bluebird'
 import { Buffer } from 'buffer'
-import { createHash } from 'crypto'
+import { createReadStream, ReadStream } from 'fs'
-import { createReadStream } from 'fs'
-import { Readable } from 'stream'
 import { spawn } from 'child_process'
-import { Stream as Needle } from 'nigel'
+import { Logger, LogStep } from './logger'
-import { Logger } from './logger'
+import {
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
+  readFileAsync,
-import { NexeOptions } from './options'
+  writeFileAsync,
+  pathExistsAsync,
+  statAsync,
+  dequote,
+  isWindows,
+  bound,
+  semverGt,
+  wrap,
+} from './util'
+import { NexeOptions, version } from './options'
+import { NexeTarget } from './target'
+import { PassThrough, Readable, Stream, Transform } from 'stream'
+import MultiStream = require('multistream')
+import { Bundle, toStream } from './fs/bundle'
+import { File } from 'resolve-dependencies'
+import { FactoryStream, LazyStream } from 'multistream'
 
 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
 const configure = isWindows ? 'configure' : './configure'
-const marker = Buffer.from('<nexe~sentinel>').toString('hex')
+
-const tail = `\n//${marker}`
+type StringReplacer = (match: string) => string
-const needle = Buffer.from(marker)
-const fixedIntegerLength = 10
-const padLeft = (x: string | number, l = fixedIntegerLength, c = '0') => (c.repeat(l) + x).slice(-l)
-const inflate = (value: string, size: number) => {
-  if (!size || value.length >= size) {
-    return value
-  }
-  return value + ' '.repeat(size - value.length)
-}
 
 export interface NexeFile {
   filename: string
-  contents: string
+  absPath: string
+  contents: string | Buffer
 }
 
-interface NexeHeader {
+export { NexeOptions }
-  /**
+
-   * Zero padded number indicating the extra size available in the binary
+export class NexeError extends Error {
-   */
+  constructor(m: string) {
-  paddingSize: string
+    super(m)
-  /**
+    Object.setPrototypeOf(this, NexeError.prototype)
-   *
+  }
-   */
-  binaryOffset: string
-  version: string
 }
 
 export class NexeCompiler {
+  /**
+   * Epoch of when compilation started
+   */
   private start = Date.now()
-  private env = { ...process.env }
+  private compileStep: LogStep | undefined
-  private compileStep: { modify: Function; log: Function }
   public log = new Logger(this.options.loglevel)
-  public src = join(this.options.temp, this.options.version)
+  /**
+   * Copy of process.env
+   */
+  public env = { ...process.env }
+  /**
+   * Virtual FileSystem
+   */
+  public bundle: Bundle
+  /**
+   * Root directory for the source of the current build
+   */
+  public src: string
+  /**
+   * In memory files that are being manipulated by the compiler
+   */
   public files: NexeFile[] = []
-  public input: string
+  /**
-  public output: string | null
+   * Standalone pieces of code run before the application entrypoint
-
+   */
-  public resources: { bundle: string; index: { [key: string]: number[] } } = {
+  public shims: string[] = []
-    index: {},
+  /**
-    bundle: ''
+   * The last shim (defaults to "require('module').runMain()")
-  }
+   */
-  public readFileAsync: (file: string) => Promise<NexeFile>
+  public startup: string = ''
-  public writeFileAsync: (file: string, contents: Buffer | string) => Promise<void>
+  /**
-  public replaceInFileAsync: (file: string, replacer: any, replaceValue: string) => Promise<void>
+   * The main entrypoint filename for your application - eg. node mainFile.js
-  public setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>
+   */
-
+  public entrypoint: string | undefined
-  private nodeSrcBinPath = isWindows
+  /**
-    ? join(this.src, 'Release', 'node.exe')
+   * Not used
-    : join(this.src, 'out', 'Release', 'node')
+   */
+  public targets: NexeTarget[]
+  /**
+   * Current target of the compiler
+   */
+  public target: NexeTarget
+  /**
+   * Output filename (-o myapp.exe)
+   */
+  public output = this.options.output
+  /**
+   * Flag to indicate whether or notstdin was used for input
+   */
+  public stdinUsed = false
+  /**
+   * Path to the configure script
+   */
+  public configureScript: string
+  /**
+   * The file path of node binary
+   */
+  public nodeSrcBinPath: string
+  /**
+   * Remote asset path if available
+   */
+  public remoteAsset: string
 
   constructor(public options: NexeOptions) {
     const { python } = (this.options = options)
-
+    //SOMEDAY iterate over multiple targets with `--outDir`
-    if (python) {
+    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 or https): ${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
+      ? join(this.src, 'Release', 'node.exe')
+      : join(this.src, 'out', 'Release', 'node')
+    this.log.step('nexe ' + version, 'info')
+    this.bundle = new Bundle(options)
     if (isWindows) {
-        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
+      const originalPath = process.env.PATH
+      delete process.env.PATH
+      this.env = { ...process.env }
+      this.env.PATH = python
+        ? (this.env.PATH = dequote(normalize(python)) + delimiter + originalPath)
+        : originalPath
+      process.env.PATH = originalPath
     } else {
-        this.env.PYTHON = python
+      this.env = { ...process.env }
+      python && (this.env.PYTHON = python)
     }
   }
 
-    this.readFileAsync = async (file: string) => {
+  @bound
-      let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+  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))
     if (!cachedFile) {
+      const absPath = join(this.src, file)
       cachedFile = {
+        absPath,
         filename: file,
-          contents: await readFileAsync(join(this.src, file), 'utf-8').catch(
+        contents: await readFileAsync(absPath, 'utf-8').catch((x) => {
-            { code: 'ENOENT' },
+          if (x.code === 'ENOENT') return ''
-            () => ''
+          throw x
-          )
+        }),
       }
       this.files.push(cachedFile)
     }
     return cachedFile
   }
-    this.writeFileAsync = (file, contents) => writeFileAsync(join(this.src, file), contents)
+
-    this.replaceInFileAsync = async (file, replace: string | RegExp, value: string) => {
+  @bound
-      const entry = await this.readFileAsync(file)
+  writeFileAsync(file: string, contents: string | Buffer) {
-      entry.contents = entry.contents.replace(replace, value)
+    this.assertBuild()
+    return writeFileAsync(join(this.src, file), contents)
   }
-    this.setFileContentsAsync = async (file: string, contents: string) => {
+
+  @bound
+  async replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = entry.contents.toString().replace(replace, value as any)
+  }
+
+  @bound
+  async setFileContentsAsync(file: string, contents: string | Buffer) {
     const entry = await this.readFileAsync(file)
     entry.contents = contents
   }
-  }
 
-  quit(code = 0) {
+  quit(error?: any) {
     const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
+    this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green')
-    return this.log.flush().then(x => process.exit(code))
+    return this.log.flush()
   }
 
-  private _findPaddingSize(size: number, override = this.options.padding) {
+  assertBuild() {
-    if (override === 0) {
+    if (!this.options.build) {
-      return 0
+      throw new NexeError('This feature is only available with `--build`')
     }
-    size = override > size ? override : size
-    const padding = [3, 6, 9, 16, 25, 40].map(x => x * 1e6).find(p => size <= p)
-    if (!padding) {
-      throw new Error(
-        `No prebuilt target large enough (${(size / 1024).toFixed(
-          2
-        )}Mb).\nUse the --build flag and build for the current platform`
-      )
-    }
-    return padding
   }
 
-  private _getNodeExecutableLocation(target?: string | null) {
+  public getNodeExecutableLocation(target?: NexeTarget) {
+    if (this.options.asset) {
+      return resolve(this.options.cwd, this.options.asset)
+    }
     if (target) {
-      return join(this.options.temp, target)
+      return join(this.options.temp, target.toString())
     }
     return this.nodeSrcBinPath
   }
 
   private _runBuildCommandAsync(command: string, args: string[]) {
-    return new Bluebird((resolve, reject) => {
+    if (this.log.verbose) {
+      this.compileStep!.pause()
+    }
+    return new Promise<void>((resolve, reject) => {
       spawn(command, args, {
         cwd: this.src,
         env: this.env,
-        stdio: 'ignore'
+        stdio: this.log.verbose ? 'inherit' : 'ignore',
+      })
+        .once('error', (e: Error) => {
+          if (this.log.verbose) {
+            this.compileStep!.resume()
+          }
+          reject(e)
+        })
+        .once('close', (code: number) => {
+          if (this.log.verbose) {
+            this.compileStep!.resume()
+          }
+          if (code != 0) {
+            const error = `${command} ${args.join(' ')} exited with code: ${code}`
+            reject(new NexeError(error))
+          }
+          resolve()
         })
-        .once('error', reject)
-        .once('close', resolve)
     })
   }
 
   private _configureAsync() {
+    if (isWindows && semverGt(this.target.version, '10.15.99')) {
+      return Promise.resolve()
+    }
     return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
-      configure,
+      this.configureScript,
-      ...this.options.configure
+      ...this.options.configure,
     ])
   }
 
-  private async _buildAsync() {
+  public async build(): Promise<ReadStream> {
-    this.compileStep.log(`Configuring node build: ${this.options.configure}`)
+    this.compileStep!.log(
+      `Configuring node build${
+        this.options.configure.length ? ': ' + this.options.configure : '...'
+      }`
+    )
     await this._configureAsync()
-    const buildOptions = isWindows ? this.options.vcBuild : this.options.make
+    const buildOptions = this.options.make
-    this.compileStep.log(`Compiling Node with arguments: ${buildOptions}`)
+    this.compileStep!.log(
+      `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
+    )
     await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this._getNodeExecutableLocation())
+    return createReadStream(this.getNodeExecutableLocation())
   }
 
-  private _fetchPrebuiltBinaryAsync() {
+  private async _shouldCompileBinaryAsync(binary: NodeJS.ReadableStream | null, location: string) {
-    return this._buildAsync()
+    //SOMEDAY combine make/configure/vcBuild/and modified times of included files
+    const { snapshot, build } = this.options
+
+    if (!binary) {
+      return true
     }
 
-  private _getPayload(header: NexeHeader) {
+    if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
-    return this._serializeHeader(header) + this.input + '/**' + this.resources.bundle + `**/`
+      const snapshotLastModified = (await statAsync(snapshot)).mtimeMs
+      const binaryLastModified = (await statAsync(location)).mtimeMs
+      return snapshotLastModified > binaryLastModified
     }
 
-  private _generateHeader() {
+    return false
-    const zeros = padLeft(0)
-    const version =
-      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
-        return (a += (this.options as any)[c].slice().sort().join())
-      }, '') + this.options.enableNodeCli
-    const header = {
-      version: padLeft(0, 32),
-      resources: this.resources.index,
-      contentSize: zeros,
-      paddingSize: zeros,
-      resourceOffset: zeros,
-      binaryOffset: zeros
-    }
-    const serializedHeader = this._serializeHeader(header)
-    header.contentSize = padLeft(Buffer.byteLength(this._getPayload(header)))
-    header.paddingSize = padLeft(this._findPaddingSize(+header.contentSize))
-    header.resourceOffset = padLeft(Buffer.byteLength(serializedHeader + this.input + '/**'))
-    header.version = createHash('md5').update(version + header.paddingSize).digest('hex')
-    return header
   }
 
-  private async _getExistingBinaryHeaderAsync(target: string | undefined | null) {
+  async compileAsync(target: NexeTarget) {
-    const filename = this._getNodeExecutableLocation(target)
-    const existingBinary = await pathExistsAsync(filename)
-    if (existingBinary) {
-      return this._extractHeaderAsync(filename)
-    }
-    return null
-  }
-
-  private _extractHeaderAsync(path: string): Promise<NexeHeader> {
-    const binary = createReadStream(path)
-    const haystack = new Needle(needle)
-    let needles = 0
-    let stackCache: Buffer[] = []
-    return new Promise((resolve, reject) => {
-      binary
-        .on('error', reject)
-        .pipe(haystack)
-        .on('error', reject)
-        .on('close', () => reject(new Error(`Binary: ${path} is not compatible with nexe`)))
-        .on('haystack', (x: Buffer) => needles && stackCache.push(x))
-        .on('needle', () => {
-          if (++needles === 2) {
-            resolve(JSON.parse(Buffer.concat(stackCache).toString()))
-            binary.close()
-            haystack.end()
-          }
-        })
-    })
-  }
-
-  private _serializeHeader(header: NexeHeader) {
-    return `/**${marker}${JSON.stringify(header)}${marker}**/process.__nexe=${JSON.stringify(
-      header
-    )};`
-  }
-
-  async setMainModule(compiler: NexeCompiler, next: () => Promise<void>) {
-    await next()
-    const header = compiler._generateHeader()
-    const contents = inflate(this._getPayload(header), +header.paddingSize) + tail
-    return compiler.setFileContentsAsync(`lib/${compiler.options.name}.js`, contents)
-  }
-
-  async compileAsync() {
     const step = (this.compileStep = this.log.step('Compiling result'))
-    let target = this.options.targets.slice().shift()
+    const build = this.options.build
-    let prebuiltBinary = null
+    const location = this.getNodeExecutableLocation(build ? undefined : target)
-    const header = this._generateHeader()
+    let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
-    target = target && `${target}-${header.version.slice(0, 6)}`
+
-    step.log(`Scanning existing binary...`)
+    if (await this._shouldCompileBinaryAsync(binary, location)) {
-    const existingHeader = await this._getExistingBinaryHeaderAsync(target)
+      binary = await this.build()
-    if (existingHeader && existingHeader.version === header.version) {
-      const location = this._getNodeExecutableLocation(target)
-      step.log(`Source already built: ${location}`)
-      prebuiltBinary = createReadStream(location)
-    }
-    if (target) {
-      throw new Error('\nNot Implemented, use --build during beta\n')
-      // prebuiltBinary = await this._fetchPrebuiltBinaryAsync(target)
-    }
-    if (!prebuiltBinary) {
-      prebuiltBinary = await this._buildAsync()
       step.log('Node binary compiled')
     }
-    return this._assembleDeliverable(header, prebuiltBinary)
+    return this._assembleDeliverable(binary!)
   }
 
-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
+  code() {
-    const haystack = new Needle(Buffer.concat([Buffer.from('/**'), needle]))
+    return [this.shims.join(''), this.startup].join(';')
-    const artifact = new Readable({ read() {} })
-    let needles = 0
-    let currentStackSize = 0
-    binary.pipe(haystack)
-    haystack
-      .on('close', () => artifact.push(null))
-      .on('needle', () => ++needles && haystack.needle(needle))
-      .on('haystack', (x: Buffer) => {
-        if (!needles) {
-          currentStackSize += x.length
-          artifact.push(x)
   }
-        if (needles === 1 && !+header.binaryOffset) {
+
-          header.binaryOffset = padLeft(currentStackSize)
+  private async _assembleDeliverable(binary: Readable) {
-          const content = Buffer.from(inflate(this._getPayload(header), +header.paddingSize) + tail)
+    if (!this.options.mangle) {
-          artifact.push(content)
+      return binary
     }
-        if (needles > 2) {
+    const launchCode = this.code()
-          artifact.push(x)
+    const codeSize = Buffer.byteLength(launchCode)
+    const sentinel = Buffer.from('<nexe~~sentinel>')
+
+    let vfsSize = 0
+    const streams = [
+      binary,
+      toStream(launchCode),
+      this.bundle.toStream().pipe(
+        new Transform({
+          transform: (chunk, _, cb) => {
+            vfsSize || this.bundle.finalize()
+            chunk && (vfsSize += chunk.length)
+            cb(null, chunk)
+          },
+        })
+      ),
+    ]
+
+    let done = false
+    return new MultiStream((cb) => {
+      if (done) cb(null, null)
+      else if (streams.length) cb(null, streams.shift() as Readable)
+      else {
+        done = true
+        const trailers = Buffer.alloc(16)
+        trailers.writeDoubleLE(codeSize, 0)
+        trailers.writeDoubleLE(vfsSize, 8)
+        cb(null, toStream(Buffer.concat([sentinel, trailers])))
       }
     })
-    return artifact
   }
 }

src/download.ts

@@ -1,40 +0,0 @@
-import download = require('download')
-import { isDirectoryAsync } from './util'
-import { LogStep } from './logger'
-import { IncomingMessage } from 'http'
-import { NexeCompiler } from './compiler'
-
-function fetchNodeSourceAsync(cwd: string, url: string, step: LogStep, options = {}) {
-  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
-  return download(url, cwd, Object.assign(options, { extract: true, strip: 1 }))
-    .on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
-      let current = 0
-      res.on('data', data => {
-        current += data.length
-        setText(current / total * 100)
-        if (current === total) {
-          step.log('Extracting Node...')
-        }
-      })
-    })
-    .then(() => step.log(`Node source extracted to: ${cwd}`))
-}
-
-/**
- * Downloads the node source to the configured temporary directory
- * @param {*} compiler
- * @param {*} next
- */
-export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src, log } = compiler
-  const { version, 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 isDirectoryAsync(src)) {
-    step.log('Source already downloaded')
-    return next()
-  }
-
-  return fetchNodeSourceAsync(src, url, step, downloadOptions).then(next)
-}

src/fs/README.md

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

src/fs/SnapshotZipFS.ts

@@ -0,0 +1,395 @@
+import { Libzip } from '@yarnpkg/libzip'
+import {
+  FakeFS,
+  PortablePath,
+  RmdirOptions,
+  OpendirOptions,
+  BasePortableFakeFS,
+  Dirent,
+  Dir,
+  MkdirOptions,
+  FSPath,
+  ppath,
+  npath,
+  Filename,
+  CustomDir,
+} from '@yarnpkg/fslib'
+import { ZipFS, ZipOpenFS } from '@yarnpkg/libzip'
+import { resolve, toNamespacedPath } from 'path'
+import { constants } from 'fs'
+
+export type SnapshotZipFSOptions = {
+  baseFs: FakeFS<PortablePath>
+  libzip: Libzip | (() => Libzip)
+  zipFs: ZipFS
+  root: string
+}
+
+const uniqBy = (arr: Array<string | Dirent>, pick: (...arg: any[]) => any) => {
+  const seen = new Set()
+  return arr.filter((x) => {
+    const key = pick(x)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+function uniqReaddir(arr: Array<string | Dirent>) {
+  return uniqBy(arr, (s: string | Dirent) => (typeof s === 'string' ? s : s.name))
+}
+
+export class SnapshotZipFS extends BasePortableFakeFS {
+  zipFs: ZipFS
+  baseFs: FakeFS<PortablePath>
+  root: string
+  magic: number
+  constructor(opts: SnapshotZipFSOptions) {
+    super()
+    this.zipFs = opts.zipFs
+    this.baseFs = opts.baseFs
+    this.root = opts.root
+    this.magic = 0x2a << 24
+  }
+  private readonly fdMap: Map<number, [ZipFS, number]> = new Map()
+  private nextFd = 3
+
+  async makeCallPromise<T>(
+    p: FSPath<PortablePath>,
+    discard: () => Promise<T>,
+    accept: (zipFS: ZipFS, zipInfo: { subPath: PortablePath }) => Promise<T>,
+    { requireSubpath = true }: { requireSubpath?: boolean } = {}
+  ): Promise<T> {
+    if (typeof p !== 'string') return await discard()
+
+    const normalizedP = this.resolve(p)
+
+    const zipInfo = this.findZip(normalizedP)
+    if (!zipInfo) return await discard()
+
+    if (requireSubpath && zipInfo.subPath === '/') return await discard()
+
+    return await accept(this.zipFs, zipInfo)
+  }
+
+  makeCallSync<T>(
+    p: FSPath<PortablePath>,
+    discard: () => T,
+    accept: (zipFS: ZipFS, zipInfo: { subPath: PortablePath; archivePath: string }) => T,
+    { requireSubpath = true }: { requireSubpath?: boolean } = {}
+  ): T {
+    if (typeof p !== 'string') return discard()
+
+    const normalizedP = this.resolve(p)
+
+    const zipInfo = this.findZip(normalizedP)
+    if (!zipInfo) return discard()
+
+    if (requireSubpath && zipInfo.subPath === '/') return discard()
+
+    return accept(this.zipFs, { archivePath: '', ...zipInfo })
+  }
+
+  async realpathPromise(p: PortablePath) {
+    return await this.realpathSync(p)
+  }
+
+  realpathSync(p: PortablePath) {
+    return this.makeCallSync(
+      p,
+      () => this.baseFs.realpathSync(p),
+      (zipFs, { subPath }) => {
+        if (zipFs.lstatSync(subPath).isSymbolicLink()) {
+          return zipFs.realpathSync(subPath)
+        } else {
+          // return the original path in case it wasn't under /snapshot, e.g. if it was for a node module - otherwise the node module parent path is the wrong one (and other things resolve relative to that)
+          return p
+        }
+      }
+    )
+  }
+
+  findZip(p: PortablePath) {
+    p = this.resolve(p)
+    const snapshotPP = npath.toPortablePath('/snapshot')
+    const pathsToTry = Array.from(
+      new Set([
+        p,
+        resolve('/snapshot', p),
+        ppath.resolve(
+          snapshotPP,
+          npath.toPortablePath(
+            npath.relative(npath.fromPortablePath(this.root), npath.fromPortablePath(p))
+          )
+        ),
+        ppath.resolve(
+          snapshotPP,
+          npath.toPortablePath(
+            npath.relative(
+              toNamespacedPath(npath.fromPortablePath(this.root)),
+              toNamespacedPath(npath.fromPortablePath(p))
+            )
+          )
+        ),
+      ])
+    )
+    for (const path of pathsToTry) {
+      const portablePath = npath.toPortablePath(path)
+      if (this.zipFs.existsSync(portablePath)) {
+        return {
+          subPath: portablePath,
+        }
+      }
+    }
+  }
+
+  async copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags: number = 0) {
+    const fallback = async (
+      sourceFs: FakeFS<PortablePath>,
+      sourceP: PortablePath,
+      destFs: FakeFS<PortablePath>,
+      destP: PortablePath
+    ) => {
+      if ((flags & constants.COPYFILE_FICLONE_FORCE) !== 0)
+        throw Object.assign(
+          new Error(`EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`),
+          { code: `EXDEV` }
+        )
+      if (flags & constants.COPYFILE_EXCL && (await this.existsPromise(sourceP)))
+        throw Object.assign(
+          new Error(`EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`),
+          { code: `EEXIST` }
+        )
+
+      let content
+      try {
+        content = await sourceFs.readFilePromise(sourceP)
+      } catch (error) {
+        throw Object.assign(
+          new Error(`EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`),
+          { code: `EINVAL` }
+        )
+      }
+
+      await destFs.writeFilePromise(destP, content)
+    }
+
+    return await this.makeCallPromise(
+      sourceP,
+      async () => {
+        return await this.baseFs.copyFilePromise(sourceP, destP, flags)
+      },
+      async (zipFsS, { subPath: subPathS }) => {
+        return await fallback(zipFsS, subPathS, this.baseFs, destP)
+      }
+    )
+  }
+
+  copyFileSync(sourceP: PortablePath, destP: PortablePath, flags: number = 0) {
+    const fallback = (
+      sourceFs: FakeFS<PortablePath>,
+      sourceP: PortablePath,
+      destFs: FakeFS<PortablePath>,
+      destP: PortablePath
+    ) => {
+      if ((flags & constants.COPYFILE_FICLONE_FORCE) !== 0)
+        throw Object.assign(
+          new Error(`EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`),
+          { code: `EXDEV` }
+        )
+      if (flags & constants.COPYFILE_EXCL && this.existsSync(sourceP))
+        throw Object.assign(
+          new Error(`EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`),
+          { code: `EEXIST` }
+        )
+
+      let content
+      try {
+        content = sourceFs.readFileSync(sourceP)
+      } catch (error) {
+        throw Object.assign(
+          new Error(`EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`),
+          { code: `EINVAL` }
+        )
+      }
+
+      destFs.writeFileSync(destP, content)
+    }
+
+    return this.makeCallSync(
+      sourceP,
+      () => {
+        return this.baseFs.copyFileSync(sourceP, destP, flags)
+      },
+      (zipFsS, { subPath: subPathS }) => {
+        return fallback(zipFsS, subPathS, this.baseFs, destP)
+      }
+    )
+  }
+  async readdirPromise(p: PortablePath): Promise<Array<Filename>>
+  async readdirPromise(
+    p: PortablePath,
+    opts: { withFileTypes: false } | null
+  ): Promise<Array<Filename>>
+  async readdirPromise(p: PortablePath, opts: { withFileTypes: true }): Promise<Array<Dirent>>
+  async readdirPromise(
+    p: PortablePath,
+    opts: { withFileTypes: boolean }
+  ): Promise<Array<Filename> | Array<Dirent>>
+  async readdirPromise(
+    p: PortablePath,
+    opts?: { withFileTypes?: boolean } | null
+  ): Promise<Array<string | Dirent>> {
+    const fallback = async () => {
+      return await this.baseFs.readdirPromise(p, opts as any)
+    }
+    return await this.makeCallPromise(
+      p,
+      fallback,
+      async (zipFs, { subPath }) => {
+        const fallbackPaths: Array<string | Dirent> = await fallback().catch(() => [])
+        return Promise.resolve(
+          uniqReaddir(fallbackPaths.concat(await zipFs.readdirPromise(subPath, opts as any)))
+        )
+      },
+      {
+        requireSubpath: false,
+      }
+    )
+  }
+
+  readdirSync(p: PortablePath): Array<Filename>
+  readdirSync(p: PortablePath, opts: { withFileTypes: false } | null): Array<Filename>
+  readdirSync(p: PortablePath, opts: { withFileTypes: true }): Array<Dirent>
+  readdirSync(p: PortablePath, opts: { withFileTypes: boolean }): Array<Filename> | Array<Dirent>
+  readdirSync(p: PortablePath, opts?: { withFileTypes?: boolean } | null): Array<string | Dirent> {
+    const fallback = () => {
+      return this.baseFs.readdirSync(p, opts as any)
+    }
+    return this.makeCallSync(
+      p,
+      fallback,
+      (zipFs, { subPath }) => {
+        let fallbackPaths: Array<string | Dirent> = []
+        try {
+          fallbackPaths = fallback()
+        } catch (e) {}
+        return fallbackPaths.concat(uniqReaddir(zipFs.readdirSync(subPath, opts as any)))
+      },
+      {
+        requireSubpath: false,
+      }
+    )
+  }
+
+  async mkdirPromise(p: PortablePath, opts?: MkdirOptions) {
+    return await this.baseFs.mkdirPromise(p, opts)
+  }
+
+  mkdirSync(p: PortablePath, opts?: MkdirOptions) {
+    return this.baseFs.mkdirSync(p, opts)
+  }
+
+  async rmdirPromise(p: PortablePath, opts?: RmdirOptions) {
+    return await this.baseFs.rmdirPromise(p, opts)
+  }
+
+  rmdirSync(p: PortablePath, opts?: RmdirOptions) {
+    return this.baseFs.rmdirSync(p, opts)
+  }
+
+  async opendirPromise(p: PortablePath, opts?: OpendirOptions) {
+    return this.opendirSync(p, opts)
+  }
+
+  opendirSync(p: PortablePath, opts?: OpendirOptions) {
+    const zipInfo = this.findZip(p)
+    let zipFsDir: Dir<PortablePath> | null = null
+    if (zipInfo) {
+      zipFsDir = this.zipFs.opendirSync(zipInfo.subPath)
+    }
+    let realFsDir: Dir<PortablePath> | null = null
+    try {
+      realFsDir = this.baseFs.opendirSync(p)
+    } catch (e) {
+      if (!zipFsDir) throw e
+    }
+    const seen = new Set()
+    const nextDirent = () => {
+      const entry = realFsDir?.readSync() || zipFsDir?.readSync()
+      if (entry && !seen.has(entry.name)) {
+        seen.add(entry.name)
+        return entry
+      }
+      return null
+    }
+
+    const onClose = () => {
+      zipFsDir?.closeSync()
+      realFsDir?.closeSync()
+    }
+
+    return new CustomDir(p, nextDirent, { onClose })
+  }
+
+  accessPromise = ZipOpenFS.prototype.accessPromise
+  accessSync = ZipOpenFS.prototype.accessSync
+  appendFilePromise = ZipOpenFS.prototype.appendFilePromise
+  appendFileSync = ZipOpenFS.prototype.appendFileSync
+  chmodPromise = ZipOpenFS.prototype.chmodPromise
+  chmodSync = ZipOpenFS.prototype.chmodSync
+  fchmodPromise = ZipOpenFS.prototype.fchmodPromise
+  fchmodSync = ZipOpenFS.prototype.fchmodSync
+  chownPromise = ZipOpenFS.prototype.chownPromise
+  chownSync = ZipOpenFS.prototype.chownSync
+  fchownPromise = ZipOpenFS.prototype.fchownPromise
+  fchownSync = ZipOpenFS.prototype.fchownSync
+  closePromise = ZipOpenFS.prototype.closePromise
+  closeSync = ZipOpenFS.prototype.closeSync
+  createReadStream = ZipOpenFS.prototype.createReadStream
+  createWriteStream = ZipOpenFS.prototype.createWriteStream
+  existsPromise = ZipOpenFS.prototype.existsPromise
+  existsSync = ZipOpenFS.prototype.existsSync
+  fstatPromise = ZipOpenFS.prototype.fstatPromise
+  fstatSync = ZipOpenFS.prototype.fstatSync
+  getExtractHint = ZipOpenFS.prototype.getExtractHint
+  getRealPath = ZipOpenFS.prototype.getRealPath
+  linkPromise = ZipOpenFS.prototype.linkPromise
+  linkSync = ZipOpenFS.prototype.linkSync
+  lstatPromise = ZipOpenFS.prototype.lstatPromise
+  lstatSync = ZipOpenFS.prototype.lstatSync
+  openPromise = ZipOpenFS.prototype.openPromise
+  openSync = ZipOpenFS.prototype.openSync
+  readFilePromise = ZipOpenFS.prototype.readFilePromise
+  readFileSync = ZipOpenFS.prototype.readFileSync
+  readlinkPromise = ZipOpenFS.prototype.readlinkPromise
+  readlinkSync = ZipOpenFS.prototype.readlinkSync
+  readPromise = ZipOpenFS.prototype.readPromise
+  readSync = ZipOpenFS.prototype.readSync
+  renamePromise = ZipOpenFS.prototype.renamePromise
+  renameSync = ZipOpenFS.prototype.renameSync
+  resolve = ZipOpenFS.prototype.resolve
+  statPromise = ZipOpenFS.prototype.statPromise
+  statSync = ZipOpenFS.prototype.statSync
+  symlinkPromise = ZipOpenFS.prototype.symlinkPromise
+  symlinkSync = ZipOpenFS.prototype.symlinkSync
+  truncatePromise = ZipOpenFS.prototype.truncatePromise
+  truncateSync = ZipOpenFS.prototype.truncateSync
+  ftruncatePromise = ZipOpenFS.prototype.ftruncatePromise
+  ftruncateSync = ZipOpenFS.prototype.ftruncateSync
+  unlinkPromise = ZipOpenFS.prototype.unlinkPromise
+  unlinkSync = ZipOpenFS.prototype.unlinkSync
+  unwatchFile = ZipOpenFS.prototype.unwatchFile
+  utimesPromise = ZipOpenFS.prototype.utimesPromise
+  utimesSync = ZipOpenFS.prototype.utimesSync
+  lutimesPromise = ZipOpenFS.prototype.utimesPromise
+  lutimesSync = ZipOpenFS.prototype.utimesSync
+  watch = ZipOpenFS.prototype.watch
+  watchFile = ZipOpenFS.prototype.watchFile
+  writeFilePromise = ZipOpenFS.prototype.writeFilePromise
+  writeFileSync = ZipOpenFS.prototype.writeFileSync
+  writePromise = ZipOpenFS.prototype.writePromise
+  writeSync = ZipOpenFS.prototype.writeSync
+
+  // @ts-ignore
+  remapFd = ZipOpenFS.prototype.remapFd
+}

src/fs/bootstrap.js

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

src/fs/bundle.ts

@@ -0,0 +1,51 @@
+import { relative } from 'path'
+import { Readable } from 'stream'
+import { File } from 'resolve-dependencies'
+import archiver from 'archiver'
+
+function makeRelativeToZip(cwd: string, path: string) {
+  return '/snapshot/' + relative(cwd, path)
+}
+
+export function toStream(content: Buffer | string) {
+  const readable = new Readable({
+    read() {
+      this.push(content)
+      this.push(null)
+    },
+  })
+  return readable
+}
+export class Bundle {
+  cwd: string
+  files = new Set<string>()
+  zip: any
+  constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
+    this.cwd = cwd
+    this.zip = archiver('zip')
+  }
+
+  get list() {
+    return Array.from(this.files)
+  }
+
+  public addResource(absoluteFileName: string, content?: File | Buffer | string) {
+    const destPath = makeRelativeToZip(this.cwd, absoluteFileName)
+    if (!this.files.has(destPath)) {
+      if (content == null) {
+        this.zip.file(absoluteFileName, { name: destPath })
+      } else {
+        this.zip.append(content, { name: destPath })
+      }
+      this.files.add(destPath)
+    }
+  }
+
+  public finalize() {
+    return this.zip.finalize()
+  }
+
+  public toStream(): Readable {
+    return this.zip
+  }
+}

src/fs/package.json

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

src/fs/patch.ts

@@ -0,0 +1,112 @@
+import { ZipFS, getLibzipSync } from '@yarnpkg/libzip'
+import { patchFs, npath, PosixFS, NodeFS } from '@yarnpkg/fslib'
+import { SnapshotZipFS } from './SnapshotZipFS'
+import * as assert from 'assert'
+import * as constants from 'constants'
+import { dirname } from 'path'
+
+export interface NexeHeader {
+  blobPath: string
+  layout: {
+    resourceStart: number
+    resourceSize: number
+    contentSize: number
+    contentStart: number
+  }
+}
+
+let originalFsMethods: any = null
+let lazyRestoreFs = () => {}
+const patches = (process as any).nexe.patches || {}
+const originalPatches = { ...patches }
+delete (process as any).nexe
+
+function shimFs(binary: NexeHeader, fs: typeof import('fs') = require('fs')) {
+  if (originalFsMethods !== null) {
+    return
+  }
+
+  originalFsMethods = Object.assign({}, fs)
+
+  const realFs: typeof fs = { ...fs }
+  const nodeFs = new NodeFS(realFs)
+
+  const blob = Buffer.allocUnsafe(binary.layout.resourceSize)
+  const blobFd = realFs.openSync(binary.blobPath, 'r')
+  const bytesRead = realFs.readSync(
+    blobFd,
+    blob,
+    0,
+    binary.layout.resourceSize,
+    binary.layout.resourceStart
+  )
+  assert.equal(bytesRead, binary.layout.resourceSize)
+
+  const zipFs = new ZipFS(blob, { readOnly: true })
+  const snapshotZipFS = new SnapshotZipFS({
+    libzip: getLibzipSync(),
+    zipFs,
+    baseFs: nodeFs,
+    root: dirname(process.argv[0]),
+  })
+  const posixSnapshotZipFs = new PosixFS(snapshotZipFS)
+  patchFs(fs, posixSnapshotZipFs)
+
+  let log = (_: string) => true
+  if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
+    process.stderr.write(
+      // @ts-ignore
+      `[nexe] - FILES ${JSON.stringify(Array.from(zipFs.entries.keys()), null, 4)}\n`
+    )
+    process.stderr.write(
+      // @ts-ignore
+      `[nexe] - DIRECTORIES ${JSON.stringify(Array.from(zipFs.listings.keys()), null, 4)}\n`
+    )
+    log = (text: string) => {
+      return process.stderr.write(`[nexe] - ${text}\n`)
+    }
+  }
+  function internalModuleReadFile(this: any, original: any, ...args: any[]) {
+    log(`internalModuleReadFile ${args[0]}`)
+    try {
+      return posixSnapshotZipFs.readFileSync(args[0], 'utf-8')
+    } catch (e) {
+      return ''
+    }
+  }
+  if (patches.internalModuleReadFile) {
+    patches.internalModuleReadFile = internalModuleReadFile
+  }
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (returningArray == null) returningArray = Array.isArray(original.call(this, ''))
+    const res = internalModuleReadFile.call(this, original, ...args)
+    return returningArray && !Array.isArray(res)
+      ? res === ''
+        ? []
+        : [res, /"(main|name|type|exports|imports)"/.test(res)]
+      : res
+  }
+  patches.internalModuleStat = function (this: any, original: any, ...args: any[]) {
+    log(`internalModuleStat ${args[0]}`)
+    try {
+      const stat = posixSnapshotZipFs.statSync(args[0])
+      if (stat.isDirectory()) return 1
+      return 0
+    } catch (e) {
+      return -constants.ENOENT
+    }
+  }
+
+  lazyRestoreFs = () => {
+    Object.assign(fs, originalFsMethods)
+    Object.assign(patches, originalPatches)
+    lazyRestoreFs = () => {}
+  }
+}
+
+function restoreFs() {
+  lazyRestoreFs()
+}
+
+export { shimFs, restoreFs }

src/logger.ts

@@ -1,15 +1,17 @@
-import colors = require('chalk')
+import colors from 'chalk'
-import ora = require('ora')
+import ora from 'ora'
 
 const frameLength = 120
 
 export interface LogStep {
   modify(text: string, color?: string): void
   log(text: string, color?: string): void
+  pause(): void
+  resume(): void
 }
 
 export class Logger {
-  private verbose: boolean
+  public verbose: boolean
   private silent: boolean
   private ora: any
   private modify: Function
@@ -22,7 +24,7 @@ export class Logger {
       this.ora = ora({
         text: 'Starting...',
         color: 'blue',
-        spinner: 'dots'
+        spinner: 'dots',
       })
       this.ora.stop()
     }
@@ -33,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') {
@@ -46,20 +48,25 @@ export class Logger {
     this.ora.color = color
   }
 
-  step(text: string): LogStep {
+  step(text: string, method: string = 'succeed'): LogStep {
     if (this.silent) {
-      return { modify() {}, log() {} }
+      return { modify() {}, log() {}, pause() {}, resume() {} }
     }
     if (!this.ora.id) {
       this.ora.start().text = text
+      if (method !== 'succeed') {
+        this.ora[method]()
+      }
     } else {
-      this.ora.succeed().text = text
+      this.ora[method]().text = text
       this.ora.start()
     }
 
     return {
       modify: this.modify,
-      log: this.verbose ? this.write : this.modify
+      log: this.verbose ? this.write : this.modify,
+      pause: () => this.ora.stopAndPersist(),
+      resume: () => this.ora.start(),
     } as LogStep
   }
 }

src/nexe.ts

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

src/options.ts

@@ -1,8 +1,15 @@
-import * as parseArgv from 'minimist'
+import parseArgv from 'minimist'
-import { NexeCompiler } from './compiler'
+import { NexeCompiler, NexeError } from './compiler'
-import { basename, extname, join } from 'path'
+import { isWindows, STDIN_FLAG } from './util'
-import * as Bluebird from 'bluebird'
+import { basename, extname, join, isAbsolute, resolve } from 'path'
-import { EOL } from 'os'
+import { getTarget, NexeTarget } from './target'
+import { EOL, homedir } from 'os'
+import chalk from 'chalk'
+import { resolveSync } from 'resolve-dependencies'
+const caw = require('caw')
+const c = process.platform === 'win32' ? chalk.constructor({ enabled: false }) : chalk
+
+export const version = '{{ version }}'
 
 export interface NexePatch {
   (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -10,131 +17,125 @@ export interface NexePatch {
 
 export interface NexeOptions {
   build: boolean
-  /**
-   * Entrypoint filepath
-   */
   input: string
   output: string
-  targets: string[]
+  targets: (string | NexeTarget)[]
-  /**
-   * Build name, Used for executable, and stacktraces
-   */
   name: string
-  /**
+  remote: string
-   * The node version to be built
+  asset: string
-   */
+  cwd: string
-  version: string
+  fs: boolean | string[]
-  python?: string
-  /**
-   * Node flags e.g. "--expose-gc" baked into the executable
-   */
   flags: string[]
-  /**
-   * Pass configuration options to node build configure script
-   */
   configure: string[]
-  /**
-   * Pass make options to node make script
-   */
-  make: string[]
   vcBuild: string[]
+  make: string[]
   snapshot?: string
-  /**
-   * Array of glob strings describing resources to pull into the bundle
-   */
   resources: string[]
-  /**
-   * Temporary directory where nexe artifacts will be cached
-   * TODO dot folder in home dir
-   */
   temp: string
-  ico?: string
   rc: { [key: string]: string }
-  /**
-   * Causes nexe to remove all temporary files for current configuration
-   */
-  clean: boolean
   enableNodeCli: boolean
-  sourceUrl?: string
   bundle: boolean | string
+  patches: (string | NexePatch)[]
+  plugins: (string | NexePatch)[]
+  native: any
+  mangle: boolean
+  ghToken: string
+  sourceUrl?: string
+  enableStdIn?: boolean
+  python?: string
   loglevel: 'info' | 'silent' | 'verbose'
   silent?: boolean
+  fakeArgv?: boolean
   verbose?: boolean
   info?: boolean
-  padding: number
+  ico?: string
-  patches: NexePatch[]
+  debugBundle?: boolean
-
-  empty: boolean
   warmup?: string
-  downloadOptions?: any
+  clean?: boolean
+  /**
+   * Api Only
+   */
+  downloadOptions: any
 }
 
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
 const defaults = {
-  temp: process.env.NEXE_TEMP || join(process.cwd(), '.nexe'),
-  version: process.version.slice(1),
   flags: [],
+  cwd: process.cwd(),
+  fs: true,
   configure: [],
+  mangle: true,
   make: [],
   targets: [],
-  vcBuild: ['nosign', 'release'],
+  vcBuild: isWindows ? ['nosign', 'release'] : [],
   enableNodeCli: false,
+  build: false,
   bundle: true,
-  build: true,
+  patches: [],
-  patches: []
+  plugins: [],
+  remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
 }
 const alias = {
   i: 'input',
   o: 'output',
-  t: 'target',
-  n: 'name',
   v: 'version',
+  a: 'asset',
+  t: 'target',
+  b: 'build',
+  n: 'name',
   r: 'resource',
-  a: 'resource',
   p: 'python',
   f: 'flag',
   c: 'configure',
   m: 'make',
-  vc: 'vcBuild',
-  s: 'snapshot',
-  cli: 'enableNodeCli',
   h: 'help',
-  l: 'loglevel'
+  l: 'loglevel',
+  'fake-argv': 'fakeArgv',
+  'gh-token': 'ghToken',
 }
-const argv = parseArgv(process.argv, { alias, default: defaults })
+const argv = parseArgv(process.argv, { alias, default: { ...defaults } })
-const help = `
+let help = `
-nexe --help              CLI OPTIONS
+${c.bold('nexe <entry-file> [options]')}
+
+   ${c.underline.bold('Options:')}
+
+  -i   --input                      -- application entry point
+  -o   --output                     -- path to output file
+  -t   --target                     -- node version description
+  -n   --name                       -- main app module name
+  -r   --resource                   -- *embed files (glob) within the binary
+       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
+       --plugin                     -- extend nexe runtime behavior
+
+   ${c.underline.bold('Building from source:')}
 
   -b   --build                      -- build from source
-  -i   --input      =index.js               -- application entry point
+  -p   --python                     -- python3 (as python) executable path
-  -o   --output     =my-app.exe             -- path to output file
+  -f   --flag                       -- *v8 flags to include during compilation
-  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
+  -c   --configure                  -- *arguments to the configure step
-  -n   --name       =my-app                 -- main app module name
+  -m   --make                       -- *arguments to the make/build step
-  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
+       --patch                      -- module with middleware default export for adding a build patch
-  -p   --python     =/path/to/python2       -- python executable
+       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
-  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
+       --snapshot                   -- path to a warmup snapshot
-  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure command
-  -m   --make       ="--loglevel"           -- *pass arguments to the make command
-  -vc  --vcBuild    =x64                    -- *pass arguments to vcbuild.bat
-  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
-  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
-       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
-       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
-       --no-bundle                          -- set when input is already bundled
        --ico                        -- file name for alternate icon file (windows)
        --rc-*                       -- populate rc file options (windows)
-       --clean                              -- force download of sources
-       --enableNodeCli                      -- enable node cli enforcement (blocks app cli)
        --sourceUrl                  -- pass an alternate source (node.tar.gz) url
+       --enableNodeCli              -- enable node cli enforcement (blocks app cli)
+
+   ${c.underline.bold('Other options:')}
+
+       --bundle                     -- custom bundling module with 'createBundle' export
+       --temp                       -- temp file storage default '~/.nexe'
+       --cwd                        -- set the current working directory for the command
+       --fake-argv                  -- fake argv[1] with entry file
+       --clean                      -- force download of sources
        --silent                     -- disable logging
        --verbose                    -- set logging to verbose
 
        -* variable key name         * option can be used more than once`.trim()
+help = EOL + help + EOL
 
-function flattenFilter(...args: any[]): string[] {
+function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter(x => x)
+  return ([] as string[]).concat(...args).filter((x) => x)
 }
 
 /**
@@ -145,23 +146,13 @@ function flattenFilter(...args: any[]): string[] {
  */
 function extractCliMap(match: RegExp, options: any) {
   return Object.keys(options)
-    .filter(x => match.test(x))
+    .filter((x) => match.test(x))
-    .reduce((map: { [key: string]: string }, option: keyof NexeOptions) => {
+    .reduce((map: any, option: any) => {
       const key = option.split('-')[1]
       map[key] = options[option]
       delete options[option]
       return map
-    }, {})
+    }, {} as any)
-}
-
-function tryResolveMainFileName() {
-  let filename
-  try {
-    const file = require.resolve(process.cwd())
-    filename = basename(file).replace(extname(file), '')
-  } catch (_) {}
-
-  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
 }
 
 function extractLogLevel(options: NexeOptions) {
@@ -171,44 +162,145 @@ function extractLogLevel(options: NexeOptions) {
   return 'info'
 }
 
+function isName(name: string) {
+  return name && name !== 'index' && name !== STDIN_FLAG
+}
+
 function extractName(options: NexeOptions) {
   let name = options.name
-  if (typeof options.input === 'string' && !name) {
+  //try and use the input filename as the output filename if its not index
+  if (!isName(name) && typeof options.input === 'string') {
     name = basename(options.input).replace(extname(options.input), '')
   }
-  name = name || tryResolveMainFileName()
+  //try and use the directory as the filename
+  if (!isName(name) && basename(options.cwd)) {
+    name = basename(options.cwd)
+  }
+
   return name.replace(/\.exe$/, '')
 }
 
-function normalizeOptionsAsync(input: Partial<NexeOptions>) {
+function padRelative(input: string) {
-  if (argv.help || argv._.some((x: string) => x === 'version')) {
+  let prefix = ''
-    process.stderr.write(argv.help ? help : '2.0.0-beta.3' + EOL, () => process.exit(0))
+  if (!input.startsWith('.')) {
+    prefix = './'
   }
-
+  return prefix + input
-  const options = Object.assign({}, defaults, input) as NexeOptions
-  const opts = options as any
-  delete opts._
-  options.loglevel = extractLogLevel(options)
-  options.name = extractName(options)
-  options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets)
-  options.make = flattenFilter(options.make)
-  options.vcBuild = flattenFilter(options.vcBuild)
-  options.configure = flattenFilter(options.configure)
-  options.resources = flattenFilter(opts.resource, options.resources)
-  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
-
-  if (options.build || options.padding === 0) {
-    options.targets = []
-    options.build = true
-  } else if (!options.targets.length) {
-    const defaultTarget = [process.platform, process.arch, options.version].join('-')
-    options.targets = [defaultTarget]
-  }
-
-  Object.keys(alias).filter(k => k !== 'rc').forEach(x => delete opts[x])
-
-  return Promise.resolve(options)
 }
 
-export { argv, normalizeOptionsAsync }
+function isEntryFile(filename?: string): filename is string {
+  return Boolean(filename && !isAbsolute(filename))
+}
+
+export function resolveEntry(
+  input: string,
+  cwd: string,
+  maybeEntry: string | undefined,
+  bundle: boolean | string
+) {
+  let result = null
+  if (input === '-' || maybeEntry === '-') {
+    return STDIN_FLAG
+  }
+  if (input && isAbsolute(input)) {
+    return input
+  }
+  if (input) {
+    const inputPath = padRelative(input)
+    result = resolveSync(cwd, inputPath)
+  }
+  if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
+    const inputPath = padRelative(maybeEntry)
+    result = resolveSync(cwd, inputPath)
+  }
+  if (!process.stdin.isTTY && (!result || !result.absPath) && bundle === defaults.bundle) {
+    return STDIN_FLAG
+  }
+  if (!result || !result.absPath) {
+    result = resolveSync(cwd, '.')
+  }
+  if (!result.absPath) {
+    throw new NexeError(`Entry file "${input || ''}" not found!`)
+  }
+  return result.absPath
+}
+
+function isCli(options?: Partial<NexeOptions>) {
+  return argv === options
+}
+
+function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
+  const options = Object.assign({}, defaults, input) as NexeOptions
+  const opts = options as any
+  const cwd = (options.cwd = resolve(options.cwd))
+  options.temp = options.temp
+    ? resolve(cwd, options.temp)
+    : process.env.NEXE_TEMP || join(homedir(), '.nexe')
+  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined
+  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle)
+  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG
+  options.name = extractName(options)
+  options.loglevel = extractLogLevel(options)
+  options.flags = flatten(opts.flag, options.flags)
+  options.targets = flatten(opts.target, options.targets).map(getTarget)
+  if (!options.targets.length) {
+    options.targets.push(getTarget())
+  }
+  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || ''
+  options.make = flatten(isWindows ? options.vcBuild : options.make)
+  options.configure = flatten(options.configure)
+  options.resources = flatten(opts.resource, options.resources)
+
+  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)'
+  options.downloadOptions.agent = process.env.HTTPS_PROXY
+    ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
+    : options.downloadOptions.agent || require('https').globalAgent
+  options.downloadOptions.rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED
+    ? false
+    : true
+
+  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
+  options.output =
+    (options.targets[0] as NexeTarget).platform === 'windows'
+      ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
+      : `${options.output || options.name}`
+  options.output = resolve(cwd, options.output)
+
+  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) {
+      options.make = Array.from(new Set(options.make.concat(arch)))
+    } else {
+      options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
+    }
+  }
+
+  Object.keys(alias)
+    .filter((k) => k !== 'rc')
+    .forEach((x) => delete opts[x])
+
+  return options
+}
+
+export { argv, normalizeOptions, help }

src/patches/boot-nexe.ts

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

src/patches/build-fixes.ts

@@ -0,0 +1,17 @@
+import { NexeCompiler } from '../compiler'
+
+export default async function buildFixes(compiler: NexeCompiler, next: () => Promise<void>) {
+  if (!compiler.target.version.startsWith('8.2')) {
+    return next()
+  }
+
+  const file = await compiler.readFileAsync('./tools/msvs/find_python.cmd')
+
+  await compiler.replaceInFileAsync(
+    './tools/msvs/find_python.cmd',
+    '%p%python.exe -V 2>&1',
+    '"%p%python.exe" -V 2>&1'
+  )
+
+  return next()
+}

src/patches/disable-node-cli.ts

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

src/patches/gyp.ts

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

src/patches/index.ts

@@ -1,19 +1,12 @@
 import gyp from './gyp'
-import nexePatches from './third-party-main'
+import bootNexe from './third-party-main'
+import buildFixes from './build-fixes'
 import cli from './disable-node-cli'
 import flags from './flags'
 import ico from './ico'
 import rc from './node-rc'
-import { NexeCompiler } from '../compiler'
+import snapshot from './snapshot'
 
-const patches = [
+const patches = [gyp, bootNexe, buildFixes, cli, flags, ico, rc, snapshot]
-  gyp,
-  (compiler: NexeCompiler, next: () => Promise<void>) => compiler.setMainModule(compiler, next),
-  nexePatches,
-  cli,
-  flags,
-  ico,
-  rc
-]
 
 export default patches

src/patches/node-rc.ts

@@ -8,11 +8,20 @@ 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.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) => {
+    if (options[x]) {
+      file.contents = file.contents
+        .toString()
+        .replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
+    }
   })
 
   return next()

src/patches/snapshot.ts

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

src/patches/third-party-main.ts

@@ -1,83 +1,118 @@
 import { NexeCompiler } from '../compiler'
+import { parse } from 'meriyah'
+import { wrap, semverGt } from '../util'
+
+function walkSome(node: any, visit: Function) {
+  if (!node || typeof node.type !== 'string' || node._visited) {
+    return false
+  }
+  visit(node)
+  node._visited = true
+  for (let childNode in node) {
+    const child = node[childNode]
+    if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) {
+        if (walkSome(child[i], visit)) {
+          return true
+        }
+      }
+    } else if (walkSome(child, visit)) {
+      return true
+    }
+  }
+  return false
+}
 
 export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
+  let bootFile = 'lib/internal/bootstrap_node.js'
+  const { version } = compiler.target
+
+  if (version.startsWith('4.')) {
+    bootFile = 'src/node.js'
+  } else if (semverGt(version, '18.11.99')) {
+    bootFile = 'lib/internal/process/pre_execution.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.toString(), {
+      next: true,
+      globalReturn: true,
+      loc: true,
+      specDeviation: true,
+    }),
+    location = { start: { line: 0 } }
+
+  walkSome(ast, (node: any) => {
+    if (!location.start.line && node.type === 'BlockStatement') {
+      //Find the first block statement and mark the location
+      Object.assign(location, node.loc)
+      return true
+    }
+  })
+
+  const fileLines = file.contents.toString().split('\n')
+  if (semverGt(version, '19.99')) {
+    await compiler.replaceInFileAsync(
+      'lib/internal/modules/cjs/loader.js',
+      "'use strict';",
+      "'use strict';\n" + '{{ file("lib/fs/bootstrap.js") }}' + '\n'
+    )
+    fileLines.splice(location.start.line, 0, 'expandArgv1 = false;')
+  } else {
+    fileLines.splice(
+      location.start.line,
+      0,
+      '{{ file("lib/fs/bootstrap.js") }}' +
+        '\n' +
+        (semverGt(version, '11.99') ? 'expandArgv1 = false;\n' : '')
+    )
+  }
+  file.contents = fileLines.join('\n')
+
+  if (semverGt(version, '11.99')) {
+    if (semverGt(version, '12.17.99')) {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializeFrozenIntrinsics();',
+        'initializeFrozenIntrinsics();\n' + wrap('{{ file("lib/patches/boot-nexe.js") }}')
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializePolicy();',
+        'initializePolicy();\n' + wrap('{{ file("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',
-    `
+      '{{ file("lib/patches/boot-nexe.js") }}'
-const fs = require('fs')
-const Buffer = require('buffer').Buffer
-const isString = x => typeof x === 'string' || x instanceof String
-
-Object.defineProperty(process, '__nexe', (function () {
-  let nexeHeader = null
-  return {
-    get: function () {
-      return nexeHeader
-    },
-    set: function (value) {
-      if (nexeHeader) {
-        throw new Error('__nexe cannot be reconfigured')
-      }
-      nexeHeader = value
-      Object.freeze(nexeHeader)
-    },
-    enumerable: false,
-    configurable: false
-  }
-})());
-
-const originalReadFile = fs.readFile
-const originalReadFileSync = fs.readFileSync
-
-fs.readFile = function readFile (file, options, callback) {
-  const manifest = process.__nexe
-  const entry = manifest && manifest.resources[file]
-  if (!manifest || !entry || !isString(file)) {
-    return originalReadFile.apply(fs, arguments)
-  }
-  const [offset, length] = entry
-  const resourceOffset = +manifest.binaryOffset + +manifest.resourceOffset + offset
-  const encoding = isString(options) ? options : null
-  callback = typeof options === 'function' ? options : callback
-
-  fs.open(process.execPath, 'r', function (err, fd) {
-    if (err) return callback(err, null)
-    fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function (error, bytesRead, buffer) {
-      if (error) {
-        return fs.close(fd, function () {
-          callback(error, null)
-        })
-      }
-      fs.close(fd, function (err) {
-        if (err) {
-          return callback(err, buffer)
-        }
-        const result = Buffer.from(buffer.toString(), 'base64')
-        callback(err, encoding ? result.toString(encoding) : result)
-      })
-    })
-  })
-}
-
-fs.readFileSync = function readFileSync (file, options) {
-  const manifest = process.__nexe
-  const entry = manifest && manifest.resources[file]
-  if (!manifest || !entry || !isString(file)) {
-    return originalReadFileSync.apply(fs, arguments)
-  }
-  const [offset, length] = entry
-  const resourceOffset = +manifest.binaryOffset + +manifest.resourceOffset + offset
-  const encoding = isString(options) ? options : null
-  const fd = fs.openSync(process.execPath, 'r')
-  const result = Buffer.alloc(length)
-  fs.readSync(fd, result, 0, length, resourceOffset)
-  fs.closeSync(fd)
-  const contents = Buffer.from(result.toString(), 'base64')
-  return encoding ? contents.toString(encoding) : contents
-}
-
-require("${compiler.options.name}");
-    `.trim()
     )
+  }
   return next()
 }

src/releases.ts

@@ -0,0 +1,62 @@
+import got = require('got')
+import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target'
+export { NexeTarget }
+
+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
+  browser_download_url: string
+}
+
+export interface GitRelease {
+  tag_name: string
+  assets_url: string
+  upload_url: string
+  assets: GitAsset[]
+}
+
+interface NodeRelease {
+  version: string
+}
+
+async function getJson<T>(url: string, options?: any) {
+  return JSON.parse((await got(url, options)).body) as T
+}
+
+function isBuildableVersion(version: string) {
+  if (version === '12.11.0') {
+    return false
+  }
+  return !versionsToSkip.includes(Number(version.split('.')[0]))
+}
+
+export function getLatestGitRelease(options?: any) {
+  return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
+}
+
+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 versionMap: { [key: string]: true } = {}
+  return nodeReleases
+    .reduce((versions: NexeTarget[], { version }) => {
+      version = version.replace('v', '').trim()
+      if (!isBuildableVersion(version) || versionMap[version]) {
+        return versions
+      }
+      versionMap[version] = true
+      platforms.forEach((platform) => {
+        architectures.forEach((arch) => {
+          if (arch === 'x86' && platform === 'mac') return
+          if (arch.includes('arm')) return
+          versions.push(getTarget({ platform, arch, version }))
+        })
+      })
+      return versions
+    }, [])
+    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)))
+}

src/resource.ts

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

src/steps/artifacts.ts

@@ -0,0 +1,68 @@
+import { join, dirname } from 'path'
+import * as fs from 'fs'
+import { promisify } from 'util'
+import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
+import mkdirpAsync = require('mkdirp')
+import { NexeCompiler } from '../compiler'
+
+const unlinkAsync = promisify(fs.unlink),
+  readdirAsync = promisify(fs.readdir)
+
+function readDirAsync(dir: string): Promise<string[]> {
+  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)))
+      })
+    ).then((result) => {
+      return [].concat(...(result as any))
+    })
+  })
+}
+
+function maybeReadFileContentsAsync(file: string) {
+  return readFileAsync(file, 'utf-8').catch((e) => {
+    if (e.code === 'ENOENT') {
+      return ''
+    }
+    throw e
+  })
+}
+
+/**
+ * The artifacts step is where source patches are committed, or written as "artifacts"
+ * Steps:
+ *  - A temporary directory is created in the downloaded source
+ *  - On start, any files in that directory are restored into the source tree
+ *  - After the patch functions have run, the temporary directory is emptied
+ *  - Original versions of sources to be patched are written to the temporary directory
+ *  - Finally, The patched files are written into source.
+ */
+export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
+  const { src } = compiler
+  const temp = join(src, 'nexe')
+  await mkdirpAsync(temp)
+  const tmpFiles = await readDirAsync(temp)
+
+  await Promise.all(
+    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)))
+  return Promise.all(
+    compiler.files.map(async (file) => {
+      const sourceFile = join(src, file.filename)
+      const tempFile = join(temp, file.filename)
+      const fileContents = await maybeReadFileContentsAsync(sourceFile)
+
+      await mkdirpAsync(dirname(tempFile))
+      await writeFileAsync(tempFile, fileContents)
+      await compiler.writeFileAsync(file.filename, file.contents)
+    })
+  )
+}

src/steps/bundle.ts

@@ -0,0 +1,88 @@
+import { NexeCompiler, NexeError } from '../compiler'
+import { resolve, relative } from 'path'
+import resolveFiles, { resolveSync } from 'resolve-dependencies'
+import { dequote, STDIN_FLAG, semverGt, each } from '../util'
+import { Readable } from 'stream'
+
+function getStdIn(stdin: Readable): Promise<string> {
+  let out = ''
+  return new Promise((resolve) => {
+    stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        let current
+        while ((current = stdin.read())) {
+          out += current
+        }
+      })
+      .on('end', () => resolve(out.trim()))
+    setTimeout(() => {
+      if (!out.trim()) {
+        resolve(out.trim())
+      }
+    }, 1000)
+  })
+}
+
+export default async function bundle(compiler: NexeCompiler, next: any) {
+  const { bundle: doBundle, cwd, input: inputPath } = compiler.options
+  let input = inputPath
+  compiler.entrypoint = './' + relative(cwd, input)
+
+  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 doBundle === 'string') {
+    code = await require(doBundle).createBundle(compiler.options)
+  }
+
+  if (input === STDIN_FLAG && (code = code || dequote(await getStdIn(process.stdin)))) {
+    compiler.stdinUsed = true
+    compiler.entrypoint = './__nexe_stdin.js'
+    await compiler.addResource(resolve(cwd, compiler.entrypoint), code)
+    return next()
+  }
+
+  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 step = compiler.log.step('Resolving dependencies...')
+
+  const { files, warnings } = await resolveFiles(
+    input,
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js') || x.endsWith('.mjs')),
+    { cwd, expand: 'variable', loadContent: false }
+  )
+
+  if (
+    warnings.filter((x) => x.startsWith('Error parsing file') && !x.includes('node_modules')).length
+  ) {
+    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
+  }
+
+  //TODO: warnings.forEach((x) => console.log(x))
+
+  await Promise.all(
+    Object.entries(files).map(([key]) => {
+      step.log(`Including dependency: ${key}`)
+      return compiler.addResource(key)
+    })
+  )
+
+  return next()
+}

src/steps/clean.ts

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

src/steps/cli.ts

@@ -0,0 +1,59 @@
+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,
+ * the package.json#main file is used.
+ * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
+ *
+ * Configuration:
+ *
+ * @param {*} compiler
+ * @param {*} next
+ */
+export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
+  await next()
+  const { log } = compiler,
+    target = compiler.options.targets.shift() as NexeTarget,
+    deliverable = await compiler.compileAsync(target),
+    output = normalize(compiler.output!)
+
+  mkdirp.sync(dirname(output))
+
+  return new Promise((res, rej) => {
+    const step = log.step('Writing result to file')
+    deliverable
+      .pipe(createWriteStream(output))
+      .on('error', rej)
+      .once('close', (e: Error) => {
+        if (e) {
+          rej(e)
+        } else if (compiler.output) {
+          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))
+          step.log(
+            `Entry: '${
+              compiler.stdinUsed
+                ? compiler.options.mangle
+                  ? STDIN_FLAG
+                  : '[none]'
+                : inputFileLogOutput
+            }' written to: ${outputFileLogOutput}`
+          )
+          compiler.quit()
+          res(output)
+        }
+      })
+  })
+}

src/steps/download.ts

@@ -0,0 +1,78 @@
+import download = require('download')
+import { pathExistsAsync } from '../util'
+import { LogStep } from '../logger'
+import { IncomingMessage } from 'http'
+import { NexeCompiler, NexeError } from '../compiler'
+import { dirname } from 'path'
+
+function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
+  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
+  return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
+    .on('response', (res: IncomingMessage) => {
+      const total = +res.headers['content-length']!
+      let current = 0
+      res.on('data', (data) => {
+        current += data.length
+        setText((current / total) * 100)
+        if (current === total) {
+          step.log('Extracting Node...')
+        }
+      })
+    })
+    .then(() => step.log(`Node source extracted to: ${dest}`))
+}
+
+async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
+  const { target, remoteAsset } = compiler,
+    filename = compiler.getNodeExecutableLocation(target)
+
+  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: any) {
+    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)
+    }
+  }
+}
+
+/**
+ * Downloads the node source to the configured temporary directory
+ * @param {*} compiler
+ * @param {*} next
+ */
+export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
+  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`,
+    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...')
+    return next()
+  }
+
+  if (build) {
+    await fetchNodeSourceAsync(src, url, step, downloadOptions)
+  } else {
+    await fetchPrebuiltBinary(compiler, step)
+  }
+
+  return next()
+}

src/steps/resource.ts

@@ -0,0 +1,25 @@
+import { each } from '../util'
+import globs from 'globby'
+import { resolve } from 'path'
+import { NexeCompiler } from '../compiler'
+
+export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
+  const { cwd, resources } = compiler.options
+  if (!resources.length) {
+    return next()
+  }
+  const step = compiler.log.step('Bundling Resources...')
+  let count = 0
+
+  // 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(resolve(cwd, file))
+  })
+  step.log(`Included ${count} file(s)`)
+  return next()
+}

src/steps/shim.ts

@@ -0,0 +1,43 @@
+import { NexeCompiler } from '../compiler'
+import { wrap } from '../util'
+
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
+  await next()
+  compiler.shims.push(
+    wrap(
+      [
+        'process.__nexe = {};',
+        'const fsPatcher = (function() {',
+        'const module = {exports: {}};',
+        'const exports = module.exports;',
+        '{{file("lib/fs/patch.bundle.js")}}',
+        'return module.exports;',
+        '})()',
+        'fsPatcher.shimFs(process.__nexe);',
+        compiler.options.fs ? '' : 'restoreFs();',
+      ].join('\n')
+      //TODO support only restoring specific methods
+    )
+  )
+  compiler.shims.push(
+    wrap(`
+    if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
+      const cluster = require('cluster')
+      cluster._setupWorker()
+      delete process.env.NODE_UNIQUE_ID
+    }
+  `)
+  )
+
+  compiler.shims.push(
+    wrap(`
+      if (!process.send) {
+        const path = require('path')
+        const entry = path.resolve(path.dirname(process.execPath),${JSON.stringify(
+          compiler.entrypoint
+        )})
+        process.argv.splice(1,0, entry)
+      }
+    `)
+  )
+}

src/target.ts

@@ -0,0 +1,96 @@
+export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
+export type NodeArch = 'x86' | 'x64' | 'arm' | 'arm64'
+
+const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
+  architectures: NodeArch[] = ['x86', 'x64', 'arm', 'arm64']
+
+export { platforms, architectures }
+
+export interface NexeTarget {
+  version: string
+  platform: NodePlatform | string
+  arch: NodeArch | string
+}
+
+const prettyPlatform: { [key: string]: NodePlatform } = {
+  win32: 'windows',
+  windows: 'windows',
+  win: 'windows',
+  darwin: 'mac',
+  macos: 'mac',
+  mac: 'mac',
+  linux: 'linux',
+  static: 'alpine',
+  alpine: 'alpine',
+}
+
+const prettyArch: { [key: string]: NodeArch } = {
+  x86: 'x86',
+  arm6: 'arm',
+  arm64: 'arm64',
+  arm6l: 'arm',
+  arm: 'arm',
+  arm7: 'arm',
+  arm7l: 'arm',
+  amd64: 'x64',
+  ia32: 'x86',
+  x32: 'x86',
+  x64: 'x64',
+}
+
+function isVersion(x: string) {
+  if (!x) {
+    return false
+  }
+  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
+}
+
+function isPlatform(x: string): x is NodePlatform {
+  return x in prettyPlatform
+}
+
+function isArch(x: string): x is NodeArch {
+  return x in prettyArch
+}
+
+class Target implements NexeTarget {
+  constructor(public arch: NodeArch, public platform: NodePlatform, public version: string) {}
+  toJSON() {
+    return this.toString()
+  }
+  toString() {
+    return `${this.platform}-${this.arch}-${this.version}`
+  }
+}
+
+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 | Partial<NexeTarget> = ''): NexeTarget {
+  const currentArch = process.arch
+  let arch = currentArch in prettyArch ? prettyArch[process.arch] : (process.arch as NodeArch),
+    platform = prettyPlatform[process.platform],
+    version = process.version.slice(1)
+
+  if (typeof target !== 'string') {
+    target = `${target.platform}-${target.arch}-${target.version}`
+  }
+
+  target
+    .toLowerCase()
+    .split('-')
+    .forEach((x) => {
+      if (isVersion(x)) {
+        version = x.replace(/v/g, '')
+      }
+      if (isPlatform(x)) {
+        platform = prettyPlatform[x]
+      }
+      if (isArch(x)) {
+        arch = prettyArch[x]
+      }
+    })
+
+  return new Target(arch, platform, version)
+}

src/types.d.ts

@@ -1,23 +1,11 @@
-declare module 'nigel' {
+declare module 'got' {
-  import { Writable } from 'stream'
+  interface GotFn {
-  interface Needle {
+    (url: string, options?: any): Promise<{ body: string }>
-    value: Buffer
+    stream(url: string, optoins?: any): any
-    lastPos: number
-    last: number
-    length: number
-    badCharShift: Buffer
-  }
-
-  export function compile(needle: Buffer): Needle
-  export function horspool(haystack: Buffer, needle: Needle, start: number): number
-  export function all(haystack: Buffer, needle: Needle, pos: number): number[]
-  export class Stream extends Writable {
-    constructor(needle: Buffer)
-    needle(needle: Buffer): void
-    flush(): void
   }
+  const got: GotFn
+  export = got
 }
-
 declare module 'download' {
   import { Duplex } from 'stream'
   interface DownloadOptions {

src/util.ts

@@ -1,9 +1,53 @@
 import { readFile, writeFile, stat } from 'fs'
-import * as Bluebird from 'bluebird'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
 import rimraf = require('rimraf')
 
-const { promisify } = Bluebird
+const rimrafAsync = promisify(rimraf)
-const rimrafAsync = (promisify(rimraf) as any) as (path: string) => Bluebird<void>
+export const STDIN_FLAG = '[stdin]'
+
+export async function each<T>(
+  list: T[] | Promise<T[]>,
+  action: (item: T, index: number, list: T[]) => Promise<any>
+) {
+  const l = await list
+  return Promise.all(l.map(action))
+}
+
+export function wrap(code: string) {
+  return '!(function () {' + code + '})();'
+}
+
+function falseOnEnoent(e: any) {
+  if (e.code === 'ENOENT') {
+    return false
+  }
+  throw e
+}
+
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).slice(0, l)
+}
+
+const bound: MethodDecorator = function bound<T>(
+  target: Object,
+  propertyKey: string | Symbol,
+  descriptor: TypedPropertyDescriptor<T>
+) {
+  const configurable = true
+  return {
+    configurable,
+    get(this: T) {
+      const value = (descriptor.value as any).bind(this)
+      Object.defineProperty(this, propertyKey as string, {
+        configurable,
+        value,
+        writable: true,
+      })
+      return value
+    },
+  }
+}
 
 function dequote(input: string) {
   input = input.trim()
@@ -16,32 +60,54 @@ function dequote(input: string) {
 }
 
 export interface ReadFileAsync {
-  (path: string): Bluebird<Buffer>
+  (path: string): Promise<Buffer>
-  (path: string, encoding: string): Bluebird<string>
+  (path: string, encoding: string): Promise<string>
 }
 
-const readFileAsync = (promisify(readFile) as any) as ReadFileAsync
+const readFileAsync = promisify(readFile)
-const writeFileAsync = (promisify(writeFile) as any) as (
+const writeFileAsync = promisify(writeFile)
-  path: string,
-  contents: string | Buffer
-) => Promise<void>
 const statAsync = promisify(stat)
+const execFileAsync = promisify(execFile)
 const isWindows = process.platform === 'win32'
 
 function pathExistsAsync(path: string) {
-  return statAsync(path).then(x => true).catch({ code: 'ENOENT' }, () => false)
+  return statAsync(path)
+    .then((x) => true)
+    .catch(falseOnEnoent)
 }
 
 function isDirectoryAsync(path: string) {
-  return statAsync(path).then(x => x.isDirectory()).catch({ code: 'ENOENT' }, () => false)
+  return statAsync(path)
+    .then((x) => x.isDirectory())
+    .catch(falseOnEnoent)
+}
+/**
+ * @param version See if this version is greather than the second one
+ * @param operand Version to compare against
+ */
+function semverGt(version: string, operand: string) {
+  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
+  let [major, minor, patch] = operand.split('.').map(Number)
+  if (!minor) minor = 0
+  if (!patch) patch = 0
+  return (
+    cMajor > major ||
+    (cMajor === major && cMinor > minor) ||
+    (cMajor === major && cMinor === minor && cPatch > patch)
+  )
 }
 
 export {
   dequote,
+  padRight,
+  semverGt,
+  bound,
   isWindows,
   rimrafAsync,
+  statAsync,
+  execFileAsync,
   readFileAsync,
   pathExistsAsync,
   isDirectoryAsync,
-  writeFileAsync
+  writeFileAsync,
 }

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/docker.ts

@@ -0,0 +1,68 @@
+import { NexeTarget, architectures } from '../lib/target'
+import { writeFileAsync, readFileAsync } from '../lib/util'
+import got from 'got'
+import execa = require('execa')
+import { appendFileSync } from 'fs'
+
+function alpine(target: NexeTarget) {
+  return `
+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=latest
+WORKDIR /
+
+RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
+  mkdir /nexe_temp && mv /node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
+  cd /nexe_temp/\${NODE_VERSION} && \
+  ./configure --prefix=/usr --fully-static && \
+  make && make install && \
+  paxctl -cm /usr/bin/node
+
+RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
+  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=latest
+WORKDIR /
+
+RUN yarn global add nexe@\${NEXE_VERSION} && \
+  nexe --build --no-mangle -o out -t ${target.version}
+`.trim()
+}
+
+export async function runDockerBuild(target: NexeTarget) {
+  //todo switch on alpine and arm
+  const dockerfile = alpine(target)
+  await writeFileAsync('Dockerfile', dockerfile)
+  const outFilename = 'nexe-docker-build-log.txt'
+  await writeFileAsync(outFilename, '')
+  let output: any = []
+
+  try {
+    output.push(await execa(`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: any) {
+    console.log('Error running docker')
+    appendFileSync(outFilename, e.message)
+  } finally {
+    output.forEach((x: any) => {
+      appendFileSync(outFilename, x.stderr)
+      appendFileSync(outFilename, x.stdout)
+    })
+    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
+      body: await readFileAsync(outFilename),
+      method: 'PUT',
+    })
+      .then((x) => console.log('Posted docker log: ', x.body))
+      .catch((e) => console.log('Error posting log', e))
+  }
+}

tasks/post-build.ts

@@ -0,0 +1,31 @@
+import { writeFileSync, readFileSync } from 'fs'
+import { template } from 'lodash'
+
+/**
+ * post build step to insert code files into code files.
+ * And the package.json version.
+ */
+cp('src/fs/package.json', 'lib/fs/package.json')
+cp('src/fs/bootstrap.js', 'lib/fs/bootstrap.js')
+cp('src/fs/README.md', 'lib/fs/README.md')
+
+inject('lib/patches/third-party-main.js')
+inject('lib/steps/shim.js')
+inject('lib/options.js', JSON.stringify(require('../package.json').version))
+
+function inject(filename: string, version?: string) {
+  const contents = template(readFileSync(filename, 'utf8'), {
+    interpolate: /'\{\{([\s\S]*?)\}\}'/,
+  })({
+    file: (path: string) => JSON.stringify(readFileSync(path, 'utf8')),
+    version,
+  })
+  writeFileSync(filename, contents)
+  console.log(`Wrote: ${filename}`)
+}
+
+function cp(from: string, to: string) {
+  const file = readFileSync(from)
+  writeFileSync(to, file)
+  console.log('Copied: ', from, 'To: ', to)
+}

tasks/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include":[
+    "*.ts"
+  ]
+}
+

test/embeded-files/hw.txt

@@ -1 +0,0 @@
-true

test/embeded-files/index.js

@@ -1,11 +0,0 @@
-/**
- * Embedded Files Test
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
-const nexeres = require('nexeres');
-
-process.stdout.write(nexeres.get('hw.txt').toString('ascii'));

test/embeded-files/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "embededfiles-test",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "start": "node index.js"
-  },
-  "dependencies": {
-  },
-  "nexe": {
-    "input": "index.js",
-    "output": "test.nex",
-    "resourceFiles": [
-      "hw.txt"
-    ],
-    "browserify": {
-      "excludes": [],
-      "requires": []
-    },
-    "temp": "../src",
-    "debug": false,
-    "runtime": {
-      "nodeConfigureOpts": ["--fully-static"],
-      "framework": "node",
-      "version": "5.7.0"
-    }
-  }
-}

test/express-test/app.js

@@ -1,61 +0,0 @@
-var express = require('express');
-var path = require('path');
-var favicon = require('serve-favicon');
-var logger = require('morgan');
-var cookieParser = require('cookie-parser');
-var bodyParser = require('body-parser');
-var jade       = require('jade');
-
-var routes = require('./routes/index');
-var users = require('./routes/users');
-
-var app = express();
-
-// view engine setup
-app.set('views', path.join(__dirname, 'views'));
-app.set('view engine', 'jade');
-
-// uncomment after placing your favicon in /public
-//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
-app.use(logger('dev'));
-app.use(bodyParser.json());
-app.use(bodyParser.urlencoded({ extended: false }));
-app.use(cookieParser());
-app.use(express.static(path.join(__dirname, 'public')));
-
-app.use('/', routes);
-app.use('/users', users);
-
-// catch 404 and forward to error handler
-app.use(function(req, res, next) {
-  var err = new Error('Not Found');
-  err.status = 404;
-  next(err);
-});
-
-// error handlers
-
-// development error handler
-// will print stacktrace
-if (app.get('env') === 'development') {
-  app.use(function(err, req, res, next) {
-    res.status(err.status || 500);
-    res.render('error', {
-      message: err.message,
-      error: err
-    });
-  });
-}
-
-// production error handler
-// no stacktraces leaked to user
-app.use(function(err, req, res, next) {
-  res.status(err.status || 500);
-  res.render('error', {
-    message: err.message,
-    error: {}
-  });
-});
-
-
-module.exports = app;

test/express-test/bin/www

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Module dependencies.
- */
-
-var app = require('../app');
-var debug = require('debug')('express-test:server');
-var http = require('http');
-
-/**
- * Get port from environment and store in Express.
- */
-
-var port = normalizePort(process.env.PORT || '3000');
-app.set('port', port);
-
-/**
- * Create HTTP server.
- */
-
-var server = http.createServer(app);
-
-/**
- * Listen on provided port, on all network interfaces.
- */
-
-server.listen(port);
-server.on('error', onError);
-server.on('listening', onListening);
-
-/**
- * Normalize a port into a number, string, or false.
- */
-
-function normalizePort(val) {
-  var port = parseInt(val, 10);
-
-  if (isNaN(port)) {
-    // named pipe
-    return val;
-  }
-
-  if (port >= 0) {
-    // port number
-    return port;
-  }
-
-  return false;
-}
-
-/**
- * Event listener for HTTP server "error" event.
- */
-
-function onError(error) {
-  if (error.syscall !== 'listen') {
-    throw error;
-  }
-
-  var bind = typeof port === 'string'
-    ? 'Pipe ' + port
-    : 'Port ' + port;
-
-  // handle specific listen errors with friendly messages
-  switch (error.code) {
-    case 'EACCES':
-      console.error(bind + ' requires elevated privileges');
-      process.exit(1);
-      break;
-    case 'EADDRINUSE':
-      console.error(bind + ' is already in use');
-      process.exit(1);
-      break;
-    default:
-      throw error;
-  }
-}
-
-/**
- * Event listener for HTTP server "listening" event.
- */
-
-function onListening() {
-  var addr = server.address();
-  var bind = typeof addr === 'string'
-    ? 'pipe ' + addr
-    : 'port ' + addr.port;
-  debug('Listening on ' + bind);
-}
-
-process.stdout.write('true');
-process.exit(0);

test/express-test/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "express-test",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "start": "node ./bin/www"
-  },
-  "dependencies": {
-    "body-parser": "~1.13.2",
-    "cookie-parser": "~1.3.5",
-    "debug": "~2.2.0",
-    "express": "~4.13.1",
-    "jade": "~1.11.0",
-    "morgan": "~1.6.1",
-    "serve-favicon": "~2.3.0"
-  },
-  "nexe": {
-    "input": "bin/www",
-    "output": "test.nex",
-    "temp": "../src",
-    "debug": false,
-    "runtime": {
-      "framework": "node",
-      "version": "5.10.0",
-      "ignoreFlags": true
-    }
-  }
-}

test/express-test/public/stylesheets/style.css

@@ -1,8 +0,0 @@
-body {
-  padding: 50px;
-  font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
-}
-
-a {
-  color: #00B7FF;
-}

test/express-test/routes/index.js

@@ -1,9 +0,0 @@
-var express = require('express');
-var router = express.Router();
-
-/* GET home page. */
-router.get('/', function(req, res, next) {
-  res.render('index', { title: 'Express' });
-});
-
-module.exports = router;

test/express-test/routes/users.js

@@ -1,9 +0,0 @@
-var express = require('express');
-var router = express.Router();
-
-/* GET users listing. */
-router.get('/', function(req, res, next) {
-  res.send('respond with a resource');
-});
-
-module.exports = router;

test/express-test/views/error.jade

@@ -1,6 +0,0 @@
-extends layout
-
-block content
-  h1= message
-  h2= error.status
-  pre #{error.stack}

test/express-test/views/index.jade

@@ -1,5 +0,0 @@
-extends layout
-
-block content
-  h1= title
-  p Welcome to #{title}

test/express-test/views/layout.jade

@@ -1,7 +0,0 @@
-doctype html
-html
-  head
-    title= title
-    link(rel='stylesheet', href='/stylesheets/style.css')
-  body
-    block content

test/fixture/dependency.js

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

test/fixture/entry.js

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

test/fixture/package.json

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

test/flags-test/index.js

@@ -1,13 +0,0 @@
-/**
- * Test to verify if we support strict mode (flags)
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
- // "use strict"; w/o --use_strict
-
- let isStrict = (function() { return !this; })();
-
- console.log(isStrict);

test/flags-test/package.json

@@ -1,15 +0,0 @@
-{
-	"name": "flags-test",
-	"nexe": {
-		"input": "./index.js",
-		"output": "test.nex",
-		"temp": "../src",
-		"runtime": {
-			"framework": "node",
-			"version": "5.7.0",
-			"ignoreFlags": false,
-			"js-flags": "--use_strict",
-			"node-args": ""
-		}
-	}
-}

test/gulp-test-170/gulpfile.js

@@ -1,23 +0,0 @@
-"use strict";
-
-let gulp = require('gulp');
-let nexe = require('nexe');
-
-gulp.task( "compile", ( callback ) => {
-    let options = {
-        input: "index.js",
-        output: "test.nex",
-        python: "python",
-        nodeTempDir: "./tmp",
-        nodeVersion: "latest",
-        flags: false,
-        framework: "nodejs"
-    };
-
-    nexe.compile( options, ( err ) => {
-        console.log( err );
-        callback( err );
-    } );
-} );
-
-gulp.task('default', ['compile']);

test/gulp-test-170/index.js

@@ -1,2 +0,0 @@
-// it probably executed.
-console.log(true);

test/gulp-test-170/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "gulp-test-170",
-  "version": "0.0.1",
-  "description": "gulpfile.js issue #170",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Jared Allard <jaredallard@outlook.com>",
-  "license": "MIT",
-  "dependencies": {
-    "gulp": "^3.9.0",
-    "nexe": "^1.0.5"
-  },
-  "nexe": {
-    "input": "./index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "framework": "node",
-      "version": "5.7.0",
-      "ignoreFlags": true,
-      "node-args": ""
-    }
-  }
-}

test/ignoreFlags-test/index.js

@@ -1,19 +0,0 @@
-/**
- * Test to verify if we support strict mode (flags)
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
- // test.nex --help
-
- let status = false;
-
- // console.log(process.argv);
-
- if(process.argv[2]) {
-   status = true;
- }
-
- console.log(status);

test/ignoreFlags-test/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "flags-test",
-  "nexe": {
-    "input": "./index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "framework": "node",
-      "version": "5.7.0",
-      "ignoreFlags": true,
-      "node-args": ""
-    }
-  },
-  "dependencies": {}
-}

test/integration/index.js

@@ -0,0 +1,23 @@
+const { mkdtemp, copyFile } = require('fs/promises')
+const os = require('os')
+const path = require('path')
+const rimraf = require('rimraf')
+const cp = require('child_process')
+
+async function runTests() {
+  const tempdir = await mkdtemp(path.join(os.tmpdir(), 'nexe-integration-tests-'))
+  const executable = path.join(tempdir, path.basename(process.argv[0]))
+  await copyFile(process.argv[0], executable)
+  process.on('beforeExit', () => rimraf.sync(tempdir))
+  cp.spawn(executable,
+    [
+    path.join(tempdir, 'node_modules/mocha/bin/mocha.js'),
+      path.join(tempdir, 'test/integration/tests.integration-spec.js')
+    ],
+    { stdio: ['inherit', 'inherit', 'inherit', 'ipc'], cwd: tempdir }
+  ).on('exit', (code) => {
+    process.exitCode = code
+  })
+}
+
+runTests()

test/integration/tests.integration-spec.js

@@ -0,0 +1,120 @@
+const { expect } = require('chai')
+const fs = require('fs')
+const { dirname, basename } = require('path')
+
+const files = { zipFs: 'test/integration/tests.integration-spec.js', real: 'real', real2: 'real2' }
+describe('SnapshotZipFS', () => {
+  console.error('Note: these tests are order dependant, so subsequent failures are likely a flow on effect.')
+  it('checks existance from the zipFs', () => expect(fs.existsSync(files.zipFs)).to.equal(true))
+  it('checks non-existance from the zipFs', () => expect(fs.existsSync('not found')).to.equal(false))
+  it('reads from the zipFs', () => expect(fs.readFileSync(files.zipFs, 'utf8')).to.include('SnapshotZipFS'))
+  it('copies from the zipFs', () => expect(() => fs.copyFileSync(files.zipFs, files.real)).not.to.throw())
+  it('reads from the real fs', () => expect(fs.readFileSync(files.real, 'utf8')).to.include('SnapshotZipFS'))
+  it('checks non-existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(false))
+  it('copies from the real fs', () => expect(() => fs.copyFileSync(files.real, files.real2)).not.to.throw())
+  it('checks existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(true))
+  it('unlinks from the real fs', () => expect(() => fs.unlinkSync(files.real2)).not.to.throw())
+  it('symlinks the real fs', () => expect(() => fs.symlinkSync('tmp', files.real2)).not.to.throw())
+  it('readlinks the real fs', () => expect(fs.readlinkSync(files.real2)).to.equal('tmp'))
+  it('truncates the real fs', () => expect(() => fs.truncateSync(files.real)).not.to.throw())
+  it('writeFiles the real fs', () => expect(() => fs.writeFileSync(files.real2, 'testing')).not.to.throw())
+  it('accesses the real fs', () => expect(() => fs.accessSync(files.real)).not.to.throw())
+  it('accesses the zipFs', () => expect(() => fs.accessSync(files.zipFs)).not.to.throw())
+  it('stats the real fs', () => expect(fs.statSync(files.real2).size).to.be.greaterThan(0))
+  it('stats the zipFs', () => expect(fs.statSync(files.zipFs).size).to.be.greaterThan(0))
+  it('readdirs from the zipFs', () => expect(fs.readdirSync(dirname(files.zipFs))).to.include(basename(files.zipFs)))
+  it('readdirs from the real fs', () => expect(fs.readdirSync('.')).to.include(files.real))
+  it('readdirs from both', () => {
+    expect(fs.readdirSync('.')).to.include(files.real),
+    expect(fs.readdirSync('.')).to.include('test')
+  })
+  let dir
+  it('opendirs the zipFs fs', async () => {
+    expect(() => dir = fs.opendirSync(dirname(files.zipFs))).not.to.throw()
+    const names = []
+    for await (const dirent of dir) {
+      names.push(dirent.name)
+    }
+    expect(names).to.include(basename(files.zipFs))
+  })
+  it('opendirs the real fs and zipFs', async () => {
+    expect(() => dir = fs.opendirSync('.')).not.to.throw()
+    const names = []
+    for await (const dirent of dir) {
+      names.push(dirent.name)
+    }
+    expect(names).to.include(files.real)
+    expect(names).to.include('test')
+  })
+  it('createWriteStreams to the real fs', () => expect(() => fs.createWriteStream('createWriteStream')).not.to.throw())
+  it('createReadStreams to the real fs', () => expect(() => fs.createReadStream(files.real)).not.to.throw())
+  it('createReadStreams to the zipFs', () => expect(() => fs.createReadStream(files.zipFs)).not.to.throw())
+  it('renames to the realFs', () => {
+    expect(() => fs.renameSync(files.real2, 'rename')).not.to.throw()
+    expect(fs.existsSync('rename')).to.equal(true)
+  })
+
+  describe('write actions to the zipFs', () => {
+    it(`won't truncate to the zipFs`, () => expect(() => fs.truncateSync(files.zipFs)).to.throw())
+    it(`won't unlink from the zipFs`, () => expect(() => fs.unlinkSync(files.zipFs)).to.throw())
+    it(`won't appendFile to the zipFs`, () => expect(() => fs.appendFileSync(files.zipFs, 'xxx')).to.throw())
+    it(`won't symlink to the zipFs`, () => expect(() => fs.symlinkSync('tmp', files.zipFs)).to.throw())
+    it(`won't chmod to the zipFs`, () => expect(() => fs.chmodSync(files.zipFs, 0o666)).to.throw())
+    it(`won't chown to the zipFs`, () => expect(() => fs.chownSync(files.zipFs, 0, 0)).to.throw())
+    it(`won't writeFile the zipFs`, () => expect(() => fs.writeFileSync(files.zipFs, 'testing')).to.throw())
+    it(`won't createWriteStreams to the zipFs`, () => expect(() => fs.createWriteStream(files.zipFs)).to.throw())
+    it(`won't rename to the zipFs`, () => expect(() => fs.renameSync(files.real, files.zipFs)).to.throw())
+  })
+
+  ;[ 'zipFs', 'real' ].forEach((k) => {
+    it(`watches the ${k} fs`, () => expect(() => fs.watch(files[k], () => null).close()).not.to.throw())
+    it(`watchFiles the ${k} fs`, () => expect(() => fs.watchFile(files[k], () => null)).not.to.throw())
+    it(`unwatchFiles the ${k} fs`, () => expect(() => fs.unwatchFile(files[k])).not.to.throw())
+  })
+  let buffer = Buffer.alloc(8092), fd
+  describe('zipfs file descriptors', () => {
+    it('opens files in the zipFs', () => {
+      expect(() => (fd = fs.openSync(files.zipFs, 'a+'))).not.to.throw()
+      expect(fd).to.not.be.null
+    })
+    it('reads file descriptors from the zipFs', () => {
+      expect(() => fs.readSync(fd, buffer)).not.to.throw()
+      expect(buffer.toString()).to.include('SnapshotZipFS')
+    })
+    it('fstats the zipFs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
+    it(`won't write to the zipFs`, () => expect(() => fs.writeSync(fd, 'xxx')).to.throw())
+    it(`won't fchmod the zipFs`, () => expect(() => fs.fchmodSync(fd)).to.throw())
+    it(`won't fchown the zipFs`, () => expect(() => fs.fchownSync(fd)).to.throw())
+    it(`won't ftruncate the zipFs`, () => expect(() => fs.ftruncateSync(fd)).to.throw())
+    it('closes file descriptors from the zipFs', () => expect(() => fs.closeSync(fd)).not.to.throw())
+  })
+  fd = null
+  buffer = Buffer.alloc(8092)
+  describe('real file descriptors', () => {
+    it('opens files in the real fs', () => {
+      expect(() => (fd = fs.openSync(files.real2, 'a+'))).not.to.throw()
+      expect(fd).to.not.be.null
+    })
+    it('reads file descriptors from the real fs', () => {
+      expect(() => fs.readSync(fd, buffer)).not.to.throw()
+      expect(buffer.toString()).to.include('SnapshotZipFS')
+    })
+    it('will write to the real fs', () => expect(() => fs.writeSync(fd, 'xxx')).not.to.throw())
+    it('fstats the real fs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
+    it('closes file descriptors from the real fs', () => expect(() => fs.closeSync(fd)).not.to.throw())
+  })
+  describe('path clashes', () => {
+    it('delegates directory creation to the real fs', () => expect(() => fs.mkdirSync('test')).not.to.throw())
+    it('delegates directory removal to the real fs', () => expect(() => fs.rmdirSync('test')).not.to.throw())
+  })
+  describe('requiring modules', () => {
+    it('resolves modules from the zipFs', () => expect(() => require('resolve-dependencies')).not.to.throw())
+    it('resolves modules from the real fs', () => {
+      fs.mkdirSync('node_modules')
+      fs.mkdirSync('node_modules/fake-package')
+      fs.writeFileSync('node_modules/fake-package/package.json', '{ "name": "fake-package", "main": "some-file.js"}')
+      fs.writeFileSync('node_modules/fake-package/some-file.js', `module.exports = { fake: 'package' }`)
+      expect(require('fake-package')).to.eql({ fake: 'package' })
+    })
+  })
+})

test/js-yaml-148/index.js

@@ -1,3 +0,0 @@
-require('js-yaml');
-
-console.log(true);

test/js-yaml-148/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "js-yaml-148",
-  "version": "1.0.0",
-  "description": "#148 js-yaml fails to work",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Jared Allard <jaredallard@outlook.com>",
-  "license": "MIT",
-  "dependencies": {
-    "js-yaml": "^3.5.2"
-  },
-  "nexe": {
-    "input": "index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "version": "5.7.0",
-      "framework": "node"
-    }
-  }
-}

test/mocha.opts

@@ -1 +0,0 @@
---timeout 100000000

test/options.spec.ts

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

test/target.spec.ts

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

test/test.js

@@ -1,249 +0,0 @@
-/**
- * Test runner for nexe
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @license MIT
- **/
-
-'use strict';
-
-const assert = require('assert');
-const fs     = require('fs');
-const path   = require('path');
-const spawn  = require('child_process').spawn;
-
-// our vars
-const NEXE_VERSION = require('../package.json').version;
-const testBase = __dirname;
-const LOG_FILE = path.join(testBase, 'test.log');
-
-if(fs.existsSync(LOG_FILE)) {
-  fs.unlinkSync(LOG_FILE);
-}
-
-let logfile = fs.createWriteStream(LOG_FILE, {
-  autoClose: false
-});
-
-const compileTest = function(test, cb) {
-  let testDir = path.join(testBase, test);
-  if(!fs.existsSync(testDir)) {
-    throw new Error('Test not found');
-    return cb(false);
-  }
-
-  let npminst = spawn('npm', ['install'], {
-    cwd: testDir
-  });
-
-  npminst.on('error', function() {
-    throw new Error('Failed to execute NPM');
-    return cb(false);
-  });
-
-  npminst.on('close', function(code) {
-    if(code !== 0) {
-      throw new Error('NPM exited with non-zero status');
-      return cb(false);
-    }
-
-    let testinst = spawn('../../bin/nexe', [], {
-      cwd: testDir
-    });
-
-    testinst.on('error', function() {
-      throw new Error('Test failed to compile');
-      return cb(false);
-    });
-
-    testinst.on('close', function(code) {
-      let err = null;
-      if(code !== 0) {
-        throw new Error('Test gave non-zero code');
-        err = false;
-      }
-
-      logfile = fs.createWriteStream(LOG_FILE);
-
-      return cb(err);
-    });
-    
-    testinst.stdout.on('data', function(d) {
-      process.stdout.write(d.toString('ascii'));
-    });
-  });
-};
-
-/**
- * Run a test-generated binary
- *
- * @param {string} test - test name (dir)
- * @param {array} optional args - array of args to pass to the binary
- * @param {function} cb - callback
- **/
-const runTest = function(test, args, cb) {
-  let testDir = path.join(testBase, test);
-  let testBin = path.join(testDir, 'test.nex')
-
-  // check params
-  if(!Array.isArray(args)) {
-    cb = args;
-    args = [];
-  }
-
-  if(!fs.existsSync(testDir)) {
-    throw new Error('Test not found');
-    return cb(false);
-  }
-
-  if(!fs.existsSync(testBin)) {
-    throw new Error('Test binary not found');
-    return cb(false);
-  }
-
-  let returned = false;
-  let testinst = spawn(testBin, args, {
-    cwd: testDir
-  })
-
-  testinst.stdout.on('data', function(d) {
-    let status = d.toString('ascii');
-
-    if(status === true || status === 'true' || status === 'true\n') {
-      testinst.stdin.pause();
-      testinst.kill();
-
-      // make it know we returned.
-      returned = true;
-
-      return cb();
-    }
-  })
-
-  testinst.on('close', function(c) {
-    if(returned !== true) {
-      throw new Error('Test failed (stdout never contained true)');
-      return cb(false);
-    }
-  });
-}
-
-console.log('NOTICE: The first test may take awhile as it may compile Node.js');
-console.log('        Monitor the log file (test.log) for progress.');
-
-
-after(function() {
-  console.log('notice: closing test.log file descriptor.')
-  logfile.end();
-});
-
-/**
- * Tests express compatability.
- **/
-describe('nexe can bundle express', function() {
-  let testname = 'express-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe and embedding files', function() {
-  let testname = 'embeded-files';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('v8 flags test (strict mode)', function() {
-  let testname = 'flags-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe can be utilized in gulp test', function() {
-  let testname = 'gulp-test-170';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe can ignore node.js flags test', function() {
-  let testname = 'ignoreFlags-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, ['--help'], function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe supports js-yaml test', function() {
-  let testname = 'js-yaml-148';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});

tsconfig.json

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

tslint.json

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

webpack.config.ts

@@ -0,0 +1,7 @@
+import * as wcp from 'webpack-config-prefabs'
+export = wcp.nodeLibrary(module, {
+  enableTypescript: true,
+  entry: './src/fs/patch.ts',
+  minimize: false,
+  outputFilepath: './lib/fs/patch.bundle.js',
+});