[v2] v2.0.0-alpha.72

* Fixed multi-line tags being minified incorrectly. Fixed self closing …

* Improved html whitespace minification fix.

.gitignore

@@ -17,8 +17,17 @@ cmd/wails/wails
 .DS_Store
 tmp
 node_modules/
+package.json.md5
+v2/test/**/frontend/dist
+v2/test/**/build/
+v2/test/frameless/icon.png
+v2/test/hidden/icon.png
+v2/test/kitchensink/frontend/public/bundle.*
+v2/pkg/parser/testproject/frontend/wails
 v2/test/kitchensink/frontend/public
-v2/internal/ffenestri/runtime.c
-v2/internal/runtime/assets/desktop.js
 v2/test/kitchensink/build/darwin/desktop/kitchensink
 v2/test/kitchensink/frontend/package.json.md5
+/v2/internal/ffenestri/windows/test/cmake-build-debug/
+!v2/internal/ffenestri/windows/x64/webview2.dll
+!v2/internal/ffenestri/windows/x64/WebView2Loader.dll
+.idea/

.vscode/settings.json

@@ -1,4 +1,8 @@
 {
   "go.formatTool": "goimports",
-  "eslint.alwaysShowStatus": true
+  "eslint.alwaysShowStatus": true,
+  "files.associations": {
+    "__locale": "c",
+    "ios": "c"
+  }
 }

CONTRIBUTORS.md

@@ -40,4 +40,5 @@ Wails is what it is because of the time and effort given by these great people.
   * [Balakrishna Prasad Ganne](https://github.com/aayush420)
   * [Charaf Rezrazi](https://github.com/Rezrazi)
   * [misitebao](https://github.com/misitebao)
-  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Amaury Tobias Quiroz](https://github.com/amaury-tobias)

README.md

@@ -147,7 +147,12 @@ This project was mainly coded to the following albums:
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fwailsapp%2Fwails.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fwailsapp%2Fwails?ref=badge_large)
 
-## Special Thank You
+## Special Thanks
+
+<p align="center" style="text-align: center">
+   A *huge* thanks to <a href="https://pace.dev"><img src="pace.jpeg"/> Pace</a> for sponsoring the project and helping the efforts to get Wails ported to Apple Silicon!<br/><br/>
+   If you are looking for a Project Management tool that's powerful but quick and easy to use, check them out!<br/><br/>
+</p>
 
 <p align="center" style="text-align: center">
    A special thank you to JetBrains for donating licenses to us!<br/><br/>

go.mod

@@ -22,7 +22,7 @@ require (
 	github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba
 	golang.org/x/image v0.0.0-20200430140353-33d19683fad8
 	golang.org/x/net v0.0.0-20200625001655-4c5254603344 // indirect
-	golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd
+	golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c
 	golang.org/x/text v0.3.0
 	gopkg.in/AlecAivazis/survey.v1 v1.8.4
 	gopkg.in/yaml.v3 v3.0.0-20190709130402-674ba3eaed22

go.sum

@@ -81,6 +81,8 @@ golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c h1:UIcGWL6/wpCfyGuJnRFJRurA+yj8RrW7Q6x2YMCXt6c=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/AlecAivazis/survey.v1 v1.8.4 h1:10xXXN3wgIhPheb5NI58zFgZv32Ana7P3Tl4shW+0Qc=

runtime/js/.eslintrc

@@ -3,12 +3,12 @@
         "browser": true,
         "es6": true,
         "amd": true,
-        "node": true,
+        "node": true
     },
     "extends": "eslint:recommended",
     "parserOptions": {
         "ecmaVersion": 2016,
-        "sourceType": "module",
+        "sourceType": "module"
     },
     "rules": {
         "indent": [

runtime/js/core/browser.js

@@ -26,7 +26,7 @@ export function OpenURL(url) {
  * Opens the given filename using the system's default file handler
  *
  * @export
- * @param {sting} filename
+ * @param {string} filename
  * @returns
  */
 export function OpenFile(filename) {

runtime/js/core/calls.js

@@ -62,7 +62,7 @@ if (window.crypto) {
 export function Call(bindingName, data, timeout) {
 
 	// Timeout infinite by default
-	if (timeout == null || timeout == undefined) {
+	if (timeout == null) {
 		timeout = 0;
 	}
 

runtime/js/core/ipc.js

@@ -45,7 +45,7 @@ function Invoke(message) {
  *
  * @export
  * @param {string} type
- * @param {string} payload
+ * @param {Object} payload
  * @param {string=} callbackID
  */
 export function SendMessage(type, payload, callbackID) {

runtime/js/runtime/.npmignore

@@ -1 +1 @@
-bridge.js
+index.js

scripts/build.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 echo "**** Checking if Wails passes unit tests ****"
-if ! go test ./...
+if ! go test ./lib/... ./runtime/... ./cmd/...
 then
     echo ""
     echo "ERROR: Unit tests failed!"

v2/NOTES.md

@@ -0,0 +1,40 @@
+
+# Packing linux
+
+  * create app, app.desktop, app.png (512x512)
+  * chmod +x app!
+  * ./linuxdeploy-x86_64.AppImage --appdir AppDir -i react.png -d react.desktop  -e react --output appimage
+
+
+# Wails Doctor
+
+Tested on:
+
+  * Debian 8
+  * Ubuntu 20.04
+  * Ubuntu 19.10
+  * Solus 4.1
+  * Centos 8
+  * Gentoo
+  * OpenSUSE/leap
+  * Fedora 31
+
+### Development
+
+Add a new package manager processor here: `v2/internal/system/packagemanager/`. IsAvailable should work even if the package is installed.
+Add your new package manager to the list of package managers in `v2/internal/system/packagemanager/packagemanager.go`:
+
+```
+var db = map[string]PackageManager{
+	"eopkg":  NewEopkg(),
+	"apt":    NewApt(),
+	"yum":    NewYum(),
+	"pacman": NewPacman(),
+	"emerge": NewEmerge(),
+	"zypper": NewZypper(),
+}
+```
+
+## Gentoo
+
+  * Setup docker image using: emerge-webrsync -x -v

v2/README.md

@@ -0,0 +1,5 @@
+# Wails v2 ALPHA
+
+This branch contains WORK IN PROGRESS! There are no guarantees. Use at your peril! 
+
+This document will be updated as progress is made.

v2/cmd/wails/internal/commands/build/README.md

@@ -0,0 +1,48 @@
+# Build
+
+The build command processes the Wails project and generates an application binary. 
+
+## Usage
+
+`wails build <flags>`
+
+### Flags
+
+| Flag           | Details      | Default |
+| :------------- | :----------- | :------ |
+| -clean | Clean the bin directory before building   | |
+| -compiler path/to/compiler  | Use a different go compiler, eg go1.15beta1 | go |
+| -ldflags "custom ld flags" | Use given ldflags | | 
+| -o path/to/binary | Compile to given path/filename | |
+| -k | Keep generated assets | |
+| -package | Create a platform specific package | |
+| -production | Compile in production mode: -ldflags="-w -s" + "-h windows" on Windows | |
+| -tags | Build tags to pass to Go compiler (quoted and space separated) | |
+| -upx | Compress final binary with UPX (if installed) | |
+| -upxflags "custom flags" | Flags to pass to upx | |
+| -v int | Verbosity level (0 - silent, 1 - default, 2 - verbose) | 1 |
+| -delve | If true, runs delve on the compiled binary | false |
+
+## The Build Process
+
+The build process is as follows:
+
+  - The flags are processed, and an Options struct built containing the build context.
+  - The type of target is determined, and a custom build process is followed for target.
+
+### Desktop Target 
+
+  - The frontend dependencies are installed. The command is read from the project file `wails.json` under the key `frontend:install` and executed in the `frontend` directory. If this is not defined, it is ignored.
+  - The frontend is then built. This command is read from the project file `wails.json` under the key `frontend:install` and executed in the `frontend` directory. If this is not defined, it is ignored.
+  - The project directory is checked to see if the `build` directory exists. If not, it is created and default project assets are copied to it.
+  - An asset bundle is then created by reading the `html` key from `wails.json` and loading the referenced file. This is then parsed, looking for local Javascript and CSS references. Those files are in turn loaded into memory, converted to C data and saved into the asset bundle located at `build/assets.h`, which also includes the original HTML.
+  - The application icon is then processed: if there is no `build/appicon.png`, a default icon is copied. On Windows, an `app.ico` file is generated from this png. On Mac, `icons.icns` is generated.
+  - If there are icons in the `build/tray` directory, these are processed, converted to C data and saved as `build/trayicons.h`, ready for the compilation step.
+  - If there are icons in the `build/dialog` directory, these are processed, converted to C data and saved as `build/userdialogicons.h`, ready for the compilation step.
+  - If the `-package` flag is given for a Windows target, the Windows assets in the `build/windows` directory are processed: manifest + icons compiled to a `.syso` file (deleted after compilation).
+  - If we are building a universal binary for Mac, the application is compiled for both `arm64` and `amd64`. The `lipo` tool is then executed to create the universal binary.
+  - If we are not building a universal binary for Mac, the application is built using `go build`, using build tags to indicate type of application and build mode (debug/production).
+  - If the `-upx` flag was provided, `upx` is invoked to compress the binary. Custom flags may be provided using the `-upxflags` flag.
+  - If the `package` flag is given for a non Windows target, the application is bundled for the platform. On Mac, this creates a `.app` with the processed icons, the `Info.plist` in `build/darwin` and the compiled binary.
+
+

v2/cmd/wails/internal/commands/build/build.go

@@ -0,0 +1,284 @@
+package build
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/wailsapp/wails/v2/internal/system"
+
+	"github.com/wailsapp/wails/v2/internal/shell"
+
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/commands/build"
+)
+
+// AddBuildSubcommand adds the `build` command for the Wails application
+func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
+
+	outputType := "desktop"
+
+	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
+
+	command := app.NewSubCommand("build", "Builds the application")
+
+	// Setup production flag
+	production := false
+	command.BoolFlag("production", "Build in production mode", &production)
+
+	// Setup pack flag
+	pack := false
+	command.BoolFlag("package", "Create a platform specific package", &pack)
+
+	compilerCommand := "go"
+	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
+
+	compress := false
+	command.BoolFlag("upx", "Compress final binary with UPX (if installed)", &compress)
+
+	compressFlags := ""
+	command.StringFlag("upxflags", "Flags to pass to upx", &compressFlags)
+
+	// Setup Platform flag
+	platform := runtime.GOOS
+	command.StringFlag("platform", "Platform to target", &platform)
+
+	// Verbosity
+	verbosity := 1
+	command.IntFlag("v", "Verbosity level (0 - silent, 1 - default, 2 - verbose)", &verbosity)
+
+	// ldflags to pass to `go`
+	ldflags := ""
+	command.StringFlag("ldflags", "optional ldflags", &ldflags)
+
+	// tags to pass to `go`
+	tags := ""
+	command.StringFlag("tags", "tags to pass to Go compiler (quoted and space separated)", &tags)
+
+	// Retain assets
+	keepAssets := false
+	command.BoolFlag("k", "Keep generated assets", &keepAssets)
+
+	// Retain assets
+	outputFilename := ""
+	command.StringFlag("o", "Output filename", &outputFilename)
+
+	// Clean build directory
+	cleanBuildDirectory := false
+	command.BoolFlag("clean", "Clean the build directory before building", &cleanBuildDirectory)
+
+	webview2 := "download"
+	command.StringFlag("webview2", "WebView2 installer strategy: download,embed,browser,error.", &webview2)
+
+	runDelve := false
+	command.BoolFlag("delve", "Runs the built binary in delve for debugging", &runDelve)
+
+	command.Action(func() error {
+
+		quiet := verbosity == 0
+
+		// Create logger
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
+
+		// Validate output type
+		if !validTargetTypes.Contains(outputType) {
+			return fmt.Errorf("output type '%s' is not valid", outputType)
+		}
+
+		if !quiet {
+			app.PrintBanner()
+		}
+
+		// Setup mode
+		mode := build.Debug
+		if production {
+			mode = build.Production
+		}
+
+		// Check platform
+		validPlatformArch := slicer.String([]string{
+			"darwin",
+			"darwin/amd64",
+			"darwin/arm64",
+			"darwin/universal",
+			"linux",
+			//"linux/amd64",
+			//"linux/arm-7",
+			"windows",
+			"windows/amd64",
+		})
+		if !validPlatformArch.Contains(platform) {
+			return fmt.Errorf("platform %s is not supported", platform)
+		}
+
+		if compress && platform == "darwin/universal" {
+			println("Warning: compress flag unsupported for universal binaries. Ignoring.")
+			compress = false
+		}
+
+		// Lookup compiler path
+		compilerPath, err := exec.LookPath(compilerCommand)
+		if err != nil {
+			return fmt.Errorf("unable to find compiler: %s", compilerCommand)
+		}
+
+		// Tags
+		userTags := []string{}
+		for _, tag := range strings.Split(tags, " ") {
+			thisTag := strings.TrimSpace(tag)
+			if thisTag != "" {
+				userTags = append(userTags, thisTag)
+			}
+		}
+
+		// Webview2 installer strategy (download by default)
+		wv2rtstrategy := ""
+		webview2 = strings.ToLower(webview2)
+		if webview2 != "" {
+			validWV2Runtime := slicer.String([]string{"download", "embed", "browser", "error"})
+			if !validWV2Runtime.Contains(webview2) {
+				return fmt.Errorf("invalid option for flag 'webview2': %s", webview2)
+			}
+			// These are the build tags associated with the strategies
+			switch webview2 {
+			case "embed":
+				wv2rtstrategy = "wv2runtime.embed"
+			case "error":
+				wv2rtstrategy = "wv2runtime.error"
+			case "browser":
+				wv2rtstrategy = "wv2runtime.browser"
+			}
+		}
+
+		// If we want to use delve we need to compile in DEBUG mode
+		if runDelve {
+			mode = build.Debug
+		}
+
+		// Create BuildOptions
+		buildOptions := &build.Options{
+			Logger:              logger,
+			OutputType:          outputType,
+			OutputFile:          outputFilename,
+			CleanBuildDirectory: cleanBuildDirectory,
+			Mode:                mode,
+			Pack:                pack,
+			LDFlags:             ldflags,
+			Compiler:            compilerCommand,
+			KeepAssets:          keepAssets,
+			Verbosity:           verbosity,
+			Compress:            compress,
+			CompressFlags:       compressFlags,
+			UserTags:            userTags,
+			WebView2Strategy:    wv2rtstrategy,
+			RunDelve:            runDelve,
+		}
+
+		// Calculate platform and arch
+		platformSplit := strings.Split(platform, "/")
+		buildOptions.Platform = platformSplit[0]
+		if system.IsAppleSilicon() {
+			buildOptions.Arch = "arm64"
+		} else {
+			buildOptions.Arch = runtime.GOARCH
+		}
+		if len(platformSplit) == 2 {
+			buildOptions.Arch = platformSplit[1]
+		}
+
+		println("Build arch =", buildOptions.Arch)
+
+		// Start a new tabwriter
+		w := new(tabwriter.Writer)
+		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
+
+		buildModeText := "debug"
+		if production {
+			buildModeText = "production"
+		}
+
+		// Write out the system information
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "App Type: \t%s\n", buildOptions.OutputType)
+		fmt.Fprintf(w, "Platform: \t%s\n", buildOptions.Platform)
+		fmt.Fprintf(w, "Arch: \t%s\n", buildOptions.Arch)
+		fmt.Fprintf(w, "Compiler: \t%s\n", compilerPath)
+		fmt.Fprintf(w, "Compress: \t%t\n", buildOptions.Compress)
+		fmt.Fprintf(w, "Build Mode: \t%s\n", buildModeText)
+		fmt.Fprintf(w, "Package: \t%t\n", buildOptions.Pack)
+		fmt.Fprintf(w, "Clean Build Dir: \t%t\n", buildOptions.CleanBuildDirectory)
+		fmt.Fprintf(w, "KeepAssets: \t%t\n", buildOptions.KeepAssets)
+		fmt.Fprintf(w, "LDFlags: \t\"%s\"\n", buildOptions.LDFlags)
+		fmt.Fprintf(w, "Tags: \t[%s]\n", strings.Join(buildOptions.UserTags, ","))
+		if len(buildOptions.OutputFile) > 0 {
+			fmt.Fprintf(w, "Output File: \t%s\n", buildOptions.OutputFile)
+		}
+		fmt.Fprintf(w, "\n")
+		w.Flush()
+
+		return doBuild(buildOptions)
+	})
+}
+
+// doBuild is our main build command
+func doBuild(buildOptions *build.Options) error {
+
+	// Start Time
+	start := time.Now()
+
+	outputFilename, err := build.Build(buildOptions)
+	if err != nil {
+		return err
+	}
+
+	// Output stats
+	elapsed := time.Since(start)
+	buildOptions.Logger.Println("")
+	buildOptions.Logger.Println(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
+	buildOptions.Logger.Println("")
+
+	if buildOptions.RunDelve {
+		// Check delve exists
+		delveExists := shell.CommandExists("dlv")
+		if !delveExists {
+			return fmt.Errorf("cannot launch delve (Is it installed?)")
+		}
+
+		// Get cwd
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		// Launch delve
+		buildOptions.Logger.Println("Launching Delve on port 2345...")
+		cmdArgs := slicer.String([]string{"--listen=:2345", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", outputFilename})
+		if buildOptions.Verbosity == build.VERBOSE {
+			buildOptions.Logger.Println("\tRunning: dlv %s", cmdArgs.Join(" "))
+		}
+		stdout, stderr, err := shell.RunCommand(cwd, "dlv", cmdArgs.AsSlice()...)
+		if buildOptions.Verbosity == build.VERBOSE || err != nil {
+			trimstdout := strings.TrimSpace(stdout)
+			if trimstdout != "" {
+				buildOptions.Logger.Println(trimstdout)
+			}
+			trimstderr := strings.TrimSpace(stderr)
+			if trimstderr != "" {
+				buildOptions.Logger.Println(trimstderr)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

v2/cmd/wails/internal/commands/dev/README.md

@@ -0,0 +1,22 @@
+# Dev
+
+The dev command allows you to develop your application through a standard browser. 
+
+## Usage
+
+`wails dev <flags>`
+
+### Flags
+
+| Flag           | Details      | Default |
+| :------------- | :----------- | :------ |
+| -compiler path/to/compiler  | Use a different go compiler, eg go1.15beta1 | go |
+| -ldflags "custom ld flags" | Use given ldflags | | 
+| -e list,of,extensions | File extensions to trigger rebuilds | go |
+| -w | Show warnings | false |
+| -v int | Verbosity level (0 - silent, 1 - default, 2 - verbose) | 1 |
+| -loglevel  | Loglevel to pass to the application - Trace, Debug, Info, Warning, Error | Debug |
+
+## How it works
+
+The project is built using a special mode that starts a webserver and starts listening to port 34115. When the frontend project is run independently, so long as the JS is wrapped with the runtime method `ready`, then the frontend will connect to the backend code via websockets. The interface should be present in your browser, and you should be able to interact with the backend as you would in a desktop app.  

v2/cmd/wails/internal/commands/dev/dev.go

@@ -0,0 +1,316 @@
+package dev
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/wailsapp/wails/v2/internal/colour"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/internal/fs"
+	"github.com/wailsapp/wails/v2/internal/process"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/commands/build"
+)
+
+func LogGreen(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Green(text))
+}
+
+func LogRed(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Red(text))
+}
+
+func LogDarkYellow(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.DarkYellow(text))
+}
+
+// AddSubcommand adds the `dev` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	command := app.NewSubCommand("dev", "Development mode")
+
+	// Passthrough ldflags
+	ldflags := ""
+	command.StringFlag("ldflags", "optional ldflags", &ldflags)
+
+	// compiler command
+	compilerCommand := "go"
+	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
+
+	// extensions to trigger rebuilds
+	extensions := "go"
+	command.StringFlag("e", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+
+	// extensions to trigger rebuilds
+	showWarnings := false
+	command.BoolFlag("w", "Show warnings", &showWarnings)
+
+	// Verbosity
+	verbosity := 1
+	command.IntFlag("v", "Verbosity level (0 - silent, 1 - default, 2 - verbose)", &verbosity)
+
+	loglevel := ""
+	command.StringFlag("loglevel", "Loglevel to use - Trace, Debug, Info, Warning, Error", &loglevel)
+
+	command.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+		app.PrintBanner()
+
+		// TODO: Check you are in a project directory
+
+		watcher, err := fsnotify.NewWatcher()
+		if err != nil {
+			return err
+		}
+		defer func(watcher *fsnotify.Watcher) {
+			err := watcher.Close()
+			if err != nil {
+				log.Fatal(err)
+			}
+		}(watcher)
+
+		var debugBinaryProcess *process.Process = nil
+		var extensionsThatTriggerARebuild = strings.Split(extensions, ",")
+
+		// Setup signal handler
+		quitChannel := make(chan os.Signal, 1)
+		signal.Notify(quitChannel, os.Interrupt, os.Kill, syscall.SIGTERM)
+
+		debounceQuit := make(chan bool, 1)
+
+		var passthruArgs []string
+		//if len(os.Args) > 2 {
+		//	passthruArgs = os.Args[2:]
+		//}
+
+		// Do initial build
+		logger.Println("Building application for development...")
+		newProcess, appBinary, err := restartApp(logger, ldflags, compilerCommand, debugBinaryProcess, loglevel, passthruArgs, verbosity)
+		if newProcess != nil {
+			debugBinaryProcess = newProcess
+		}
+
+		if err != nil {
+			return err
+		}
+		var newBinaryProcess *process.Process
+		go debounce(100*time.Millisecond, watcher.Events, debounceQuit, func(event fsnotify.Event) {
+			// logger.Println("event: %+v", event)
+
+			// Check for new directories
+			if event.Op&fsnotify.Create == fsnotify.Create {
+				// If this is a folder, add it to our watch list
+				if fs.DirExists(event.Name) {
+					if !strings.Contains(event.Name, "node_modules") {
+						err := watcher.Add(event.Name)
+						if err != nil {
+							logger.Fatal("%s", err.Error())
+						}
+						LogGreen("[New Directory] Watching new directory: %s", event.Name)
+					}
+				}
+				return
+			}
+
+			// Check for file writes
+			if event.Op&fsnotify.Write == fsnotify.Write {
+
+				var rebuild bool = false
+
+				// Iterate all file patterns
+				for _, pattern := range extensionsThatTriggerARebuild {
+					if strings.HasSuffix(event.Name, pattern) {
+						rebuild = true
+						break
+					}
+				}
+
+				if !rebuild {
+					if showWarnings {
+						LogDarkYellow("[File change] %s did not match extension list (%s)", event.Name, extensions)
+					}
+					return
+				}
+
+				LogGreen("[Attempting rebuild] %s updated", event.Name)
+
+				// Do a rebuild
+
+				// Try and build the app
+				newBinaryProcess, _, err = restartApp(logger, ldflags, compilerCommand, debugBinaryProcess, loglevel, passthruArgs, verbosity)
+				if err != nil {
+					fmt.Printf("Error during build: %s", err.Error())
+					return
+				}
+				// If we have a new process, save it
+				if newBinaryProcess != nil {
+					debugBinaryProcess = newBinaryProcess
+				}
+
+			}
+		})
+
+		// Get project dir
+		projectDir, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		// Get all subdirectories
+		dirs, err := fs.GetSubdirectories(projectDir)
+		if err != nil {
+			return err
+		}
+
+		LogGreen("Watching (sub)/directory: %s", projectDir)
+
+		// Setup a watcher for non-node_modules directories
+		dirs.Each(func(dir string) {
+			if strings.Contains(dir, "node_modules") {
+				return
+			}
+			// Ignore build directory
+			if strings.HasPrefix(dir, filepath.Join(projectDir, "build")) {
+				return
+			}
+			err = watcher.Add(dir)
+			if err != nil {
+				logger.Fatal(err.Error())
+			}
+		})
+
+		// Wait until we get a quit signal
+		quit := false
+		for quit == false {
+			select {
+			case <-quitChannel:
+				LogGreen("\nCaught quit")
+				// Notify debouncer to quit
+				debounceQuit <- true
+				quit = true
+			}
+		}
+
+		// Kill the current program if running
+		if debugBinaryProcess != nil {
+			err := debugBinaryProcess.Kill()
+			if err != nil {
+				return err
+			}
+		}
+
+		// Remove dev binary
+		err = os.Remove(appBinary)
+		if err != nil {
+			return err
+		}
+
+		LogGreen("Development mode exited")
+
+		return nil
+	})
+
+	return nil
+}
+
+// Credit: https://drailing.net/2018/01/debounce-function-for-golang/
+func debounce(interval time.Duration, input chan fsnotify.Event, quitChannel chan bool, cb func(arg fsnotify.Event)) {
+	var item fsnotify.Event
+	timer := time.NewTimer(interval)
+exit:
+	for {
+		select {
+		case item = <-input:
+			timer.Reset(interval)
+		case <-timer.C:
+			if item.Name != "" {
+				cb(item)
+			}
+		case <-quitChannel:
+			break exit
+		}
+	}
+}
+
+func restartApp(logger *clilogger.CLILogger, ldflags string, compilerCommand string, debugBinaryProcess *process.Process, loglevel string, passthruArgs []string, verbosity int) (*process.Process, string, error) {
+
+	appBinary, err := buildApp(logger, ldflags, compilerCommand, verbosity)
+	println()
+	if err != nil {
+		LogRed("Build error - continuing to run current version")
+		LogDarkYellow(err.Error())
+		return nil, "", nil
+	}
+
+	// Kill existing binary if need be
+	if debugBinaryProcess != nil {
+		killError := debugBinaryProcess.Kill()
+
+		if killError != nil {
+			logger.Fatal("Unable to kill debug binary (PID: %d)!", debugBinaryProcess.PID())
+		}
+
+		debugBinaryProcess = nil
+	}
+
+	// TODO: Generate `backend.js`
+
+	// Start up new binary with correct args
+	var args = []string{"-loglevel", loglevel}
+	if len(passthruArgs) > 0 {
+		args = append(args, passthruArgs...)
+	}
+	newProcess := process.NewProcess(logger, appBinary, args...)
+	err = newProcess.Start()
+	if err != nil {
+		// Remove binary
+		deleteError := fs.DeleteFile(appBinary)
+		if deleteError != nil {
+			logger.Fatal("Unable to delete app binary: " + appBinary)
+		}
+		logger.Fatal("Unable to start application: %s", err.Error())
+	}
+
+	return newProcess, appBinary, nil
+}
+
+func buildApp(logger *clilogger.CLILogger, ldflags string, compilerCommand string, verbosity int) (string, error) {
+
+	// Create random output file
+	outputFile := "wailsdev"
+	if runtime.GOOS == "windows" {
+		outputFile += ".exe"
+	}
+
+	// Create BuildOptions
+	buildOptions := &build.Options{
+		Logger:         logger,
+		OutputType:     "dev",
+		Mode:           build.Debug,
+		Pack:           false,
+		Platform:       runtime.GOOS,
+		LDFlags:        ldflags,
+		Compiler:       compilerCommand,
+		OutputFile:     outputFile,
+		IgnoreFrontend: true,
+		Verbosity:      verbosity,
+	}
+
+	return build.Build(buildOptions)
+
+}

v2/cmd/wails/internal/commands/doctor/doctor.go

@@ -0,0 +1,156 @@
+package doctor
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/internal/system"
+	"github.com/wailsapp/wails/v2/internal/system/packagemanager"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+)
+
+// AddSubcommand adds the `doctor` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	command := app.NewSubCommand("doctor", "Diagnose your environment")
+
+	command.Action(func() error {
+
+		logger := clilogger.New(w)
+
+		app.PrintBanner()
+
+		logger.Print("Scanning system - Please wait (this may take a long time)...")
+
+		// Get system info
+		info, err := system.GetInfo()
+		if err != nil {
+			logger.Println("Failed.")
+			return err
+		}
+		logger.Println("Done.")
+
+		// Start a new tabwriter
+		w := new(tabwriter.Writer)
+		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
+
+		// Write out the system information
+		fmt.Fprintf(w, "System\n")
+		fmt.Fprintf(w, "------\n")
+		fmt.Fprintf(w, "%s\t%s\n", "OS:", info.OS.Name)
+		fmt.Fprintf(w, "%s\t%s\n", "Version: ", info.OS.Version)
+		fmt.Fprintf(w, "%s\t%s\n", "ID:", info.OS.ID)
+
+		// Output Go Information
+		fmt.Fprintf(w, "%s\t%s\n", "Go Version:", runtime.Version())
+		fmt.Fprintf(w, "%s\t%s\n", "Platform:", runtime.GOOS)
+		fmt.Fprintf(w, "%s\t%s\n", "Architecture:", runtime.GOARCH)
+
+		// Exit early if PM not found
+		if info.PM != nil {
+			fmt.Fprintf(w, "%s\t%s\n", "Package Manager: ", info.PM.Name())
+		}
+
+		// Output Dependencies Status
+		var dependenciesMissing = []string{}
+		var externalPackages = []*packagemanager.Dependancy{}
+		var dependenciesAvailableRequired = 0
+		var dependenciesAvailableOptional = 0
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "Dependency\tPackage Name\tStatus\tVersion\n")
+		fmt.Fprintf(w, "----------\t------------\t------\t-------\n")
+
+		hasOptionalDependencies := false
+		// Loop over dependencies
+		for _, dependency := range info.Dependencies {
+
+			name := dependency.Name
+			if dependency.Optional {
+				name = "*" + name
+				hasOptionalDependencies = true
+			}
+			packageName := "Unknown"
+			status := "Not Found"
+
+			// If we found the package
+			if dependency.PackageName != "" {
+
+				packageName = dependency.PackageName
+
+				// If it's installed, update the status
+				if dependency.Installed {
+					status = "Installed"
+				} else {
+					// Generate meaningful status text
+					status = "Available"
+
+					if dependency.Optional {
+						dependenciesAvailableOptional++
+					} else {
+						dependenciesAvailableRequired++
+					}
+				}
+			} else {
+				if !dependency.Optional {
+					dependenciesMissing = append(dependenciesMissing, dependency.Name)
+				}
+
+				if dependency.External {
+					externalPackages = append(externalPackages, dependency)
+				}
+			}
+
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", name, packageName, status, dependency.Version)
+		}
+		if hasOptionalDependencies {
+			fmt.Fprintf(w, "\n")
+			fmt.Fprintf(w, "* - Optional Dependency\n")
+		}
+		w.Flush()
+		logger.Println("")
+		logger.Println("Diagnosis")
+		logger.Println("---------")
+
+		// Generate an appropriate diagnosis
+
+		if len(dependenciesMissing) == 0 && dependenciesAvailableRequired == 0 {
+			logger.Println("Your system is ready for Wails development!")
+		} else {
+			logger.Println("Your system has missing dependencies!\n")
+		}
+
+		if dependenciesAvailableRequired != 0 {
+			logger.Println("Required package(s) installation details: \n" + info.Dependencies.InstallAllRequiredCommand())
+		}
+
+		if dependenciesAvailableOptional != 0 {
+			logger.Println("Optional package(s) installation details: \n" + info.Dependencies.InstallAllOptionalCommand())
+		}
+		//
+		//if len(externalPackages) > 0 {
+		//	for _, p := range externalPackages {
+		//		if p.Optional {
+		//			print("[Optional] ")
+		//		}
+		//		logger.Println("Install " + p.Name + ": " + p.InstallCommand)
+		//	}
+		//}
+
+		if len(dependenciesMissing) != 0 {
+			// TODO: Check if apps are available locally and if so, adjust the diagnosis
+			logger.Println("Fatal:")
+			logger.Println("Required dependencies missing: " + strings.Join(dependenciesMissing, " "))
+			logger.Println("Please read this article on how to resolve this: https://wails.app/guides/resolving-missing-packages")
+		}
+
+		logger.Println("")
+		return nil
+	})
+
+	return nil
+}