Switch remote deploy to vendored source builds

Move remote deployment to a vendored source bundle built on the target host via Docker so redeploys no longer require local cross-compilation or host Go installation.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

vendor/github.com/wailsapp/wails/v2/internal/app/app.go

@@ -0,0 +1,45 @@
+package app
+
+import (
+	"context"
+
+	"github.com/wailsapp/wails/v2/internal/frontend"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// App defines a Wails application structure
+type App struct {
+	frontend frontend.Frontend
+	logger   *logger.Logger
+	options  *options.App
+
+	menuManager *menumanager.Manager
+
+	// Indicates if the app is in debug mode
+	debug bool
+
+	// Indicates if the devtools is enabled
+	devtoolsEnabled bool
+
+	// OnStartup/OnShutdown
+	startupCallback  func(ctx context.Context)
+	shutdownCallback func(ctx context.Context)
+	ctx              context.Context
+}
+
+// Shutdown the application
+func (a *App) Shutdown() {
+	if a.frontend != nil {
+		a.frontend.Quit()
+	}
+}
+
+// SetApplicationMenu sets the application menu
+func (a *App) SetApplicationMenu(menu *menu.Menu) {
+	if a.frontend != nil {
+		a.frontend.MenuSetApplicationMenu(menu)
+	}
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_bindings.go

@@ -0,0 +1,124 @@
+//go:build bindings
+
+package app
+
+import (
+	"flag"
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/gosod"
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/frontend/runtime/wrapper"
+	"github.com/wailsapp/wails/v2/internal/fs"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/project"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *App) Run() error {
+
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{
+		a.options.OnStartup,
+		a.options.OnShutdown,
+		a.options.OnDomReady,
+		a.options.OnBeforeClose,
+	}
+
+	// Check for CLI Flags
+	bindingFlags := flag.NewFlagSet("bindings", flag.ContinueOnError)
+
+	var tsPrefixFlag *string
+	var tsPostfixFlag *string
+	var tsOutputTypeFlag *string
+
+	tsPrefix := os.Getenv("tsprefix")
+	if tsPrefix == "" {
+		tsPrefixFlag = bindingFlags.String("tsprefix", "", "Prefix for generated typescript entities")
+	}
+
+	tsSuffix := os.Getenv("tssuffix")
+	if tsSuffix == "" {
+		tsPostfixFlag = bindingFlags.String("tssuffix", "", "Suffix for generated typescript entities")
+	}
+
+	tsOutputType := os.Getenv("tsoutputtype")
+	if tsOutputType == "" {
+		tsOutputTypeFlag = bindingFlags.String("tsoutputtype", "", "Output type for generated typescript entities (classes|interfaces)")
+	}
+
+	_ = bindingFlags.Parse(os.Args[1:])
+	if tsPrefixFlag != nil {
+		tsPrefix = *tsPrefixFlag
+	}
+	if tsPostfixFlag != nil {
+		tsSuffix = *tsPostfixFlag
+	}
+	if tsOutputTypeFlag != nil {
+		tsOutputType = *tsOutputTypeFlag
+	}
+
+	appBindings := binding.NewBindings(a.logger, a.options.Bind, bindingExemptions, IsObfuscated(), a.options.EnumBind)
+
+	appBindings.SetTsPrefix(tsPrefix)
+	appBindings.SetTsSuffix(tsSuffix)
+	appBindings.SetOutputType(tsOutputType)
+
+	err := generateBindings(appBindings)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// CreateApp creates the app!
+func CreateApp(appoptions *options.App) (*App, error) {
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
+
+	result := &App{
+		logger:  myLogger,
+		options: appoptions,
+	}
+
+	return result, nil
+
+}
+
+func generateBindings(bindings *binding.Bindings) error {
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	projectConfig, err := project.Load(cwd)
+	if err != nil {
+		return err
+	}
+
+	wailsjsbasedir := filepath.Join(projectConfig.GetWailsJSDir(), "wailsjs")
+
+	runtimeDir := filepath.Join(wailsjsbasedir, "runtime")
+	_ = os.RemoveAll(runtimeDir)
+	extractor := gosod.New(wrapper.RuntimeWrapper)
+	err = extractor.Extract(runtimeDir, nil)
+	if err != nil {
+		return err
+	}
+
+	goBindingsDir := filepath.Join(wailsjsbasedir, "go")
+	err = os.RemoveAll(goBindingsDir)
+	if err != nil {
+		return err
+	}
+	_ = fs.MkDirs(goBindingsDir)
+
+	err = bindings.GenerateGoBindings(goBindingsDir)
+	if err != nil {
+		return err
+	}
+
+	return fs.SetPermissions(wailsjsbasedir, 0755)
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_debug.go

@@ -0,0 +1,7 @@
+//go:build debug
+
+package app
+
+func IsDebug() bool {
+	return true
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_debug_not.go

@@ -0,0 +1,7 @@
+//go:build !debug
+
+package app
+
+func IsDebug() bool {
+	return false
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_default_unix.go

@@ -0,0 +1,18 @@
+//go:build !dev && !production && !bindings && (linux || darwin)
+
+package app
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *App) Run() error {
+	return nil
+}
+
+// CreateApp creates the app!
+func CreateApp(_ *options.App) (*App, error) {
+	return nil, fmt.Errorf(`Wails applications will not build without the correct build tags.`)
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_default_windows.go

@@ -0,0 +1,27 @@
+//go:build !dev && !production && !bindings && windows
+
+package app
+
+import (
+	"os/exec"
+
+	"github.com/wailsapp/wails/v2/internal/frontend/desktop/windows/winc/w32"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *App) Run() error {
+	return nil
+}
+
+// CreateApp creates the app!
+func CreateApp(_ *options.App) (*App, error) {
+	result := w32.MessageBox(0,
+		`Wails applications will not build without the correct build tags. 
+Please use "wails build" or press "OK" to open the documentation on how to use "go build"`,
+		"Error",
+		w32.MB_ICONERROR|w32.MB_OKCANCEL)
+	if result == 1 {
+		exec.Command("rundll32", "url.dll,FileProtocolHandler", "https://wails.io/docs/guides/manual-builds").Start()
+	}
+	return nil, nil
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_dev.go

@@ -0,0 +1,298 @@
+//go:build dev
+
+package app
+
+import (
+	"context"
+	"embed"
+	"flag"
+	"fmt"
+	iofs "io/fs"
+	"net"
+	"net/url"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/wailsapp/wails/v2/pkg/assetserver"
+
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/frontend/desktop"
+	"github.com/wailsapp/wails/v2/internal/frontend/devserver"
+	"github.com/wailsapp/wails/v2/internal/frontend/dispatcher"
+	"github.com/wailsapp/wails/v2/internal/frontend/runtime"
+	"github.com/wailsapp/wails/v2/internal/fs"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+	pkglogger "github.com/wailsapp/wails/v2/pkg/logger"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *App) Run() error {
+	err := a.frontend.Run(a.ctx)
+	a.frontend.RunMainLoop()
+	a.frontend.WindowClose()
+	if a.shutdownCallback != nil {
+		a.shutdownCallback(a.ctx)
+	}
+	return err
+}
+
+// CreateApp creates the app!
+func CreateApp(appoptions *options.App) (*App, error) {
+	var err error
+
+	ctx := context.Background()
+	ctx = context.WithValue(ctx, "debug", true)
+	ctx = context.WithValue(ctx, "devtoolsEnabled", true)
+
+	// Set up logger if the appoptions.LogLevel is an invalid value, set it to the default log level
+	appoptions.LogLevel, err = pkglogger.StringToLogLevel(appoptions.LogLevel.String())
+	if err != nil {
+		return nil, err
+	}
+
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
+
+	// Check for CLI Flags
+	devFlags := flag.NewFlagSet("dev", flag.ContinueOnError)
+
+	var assetdirFlag *string
+	var devServerFlag *string
+	var frontendDevServerURLFlag *string
+	var loglevelFlag *string
+
+	assetdir := os.Getenv("assetdir")
+	if assetdir == "" {
+		assetdirFlag = devFlags.String("assetdir", "", "Directory to serve assets")
+	}
+
+	devServer := os.Getenv("devserver")
+	if devServer == "" {
+		devServerFlag = devFlags.String("devserver", "", "Address to bind the wails dev server to")
+	}
+
+	frontendDevServerURL := os.Getenv("frontenddevserverurl")
+	if frontendDevServerURL == "" {
+		frontendDevServerURLFlag = devFlags.String("frontenddevserverurl", "", "URL of the external frontend dev server")
+	}
+
+	loglevel := os.Getenv("loglevel")
+	appLogLevel := appoptions.LogLevel.String()
+	if loglevel != "" {
+		appLogLevel = loglevel
+	}
+	loglevelFlag = devFlags.String("loglevel", appLogLevel, "Loglevel to use - Trace, Debug, Info, Warning, Error")
+
+	// If we weren't given the assetdir in the environment variables
+	if assetdir == "" {
+		// Parse args but ignore errors in case -appargs was used to pass in args for the app.
+		_ = devFlags.Parse(os.Args[1:])
+		if assetdirFlag != nil {
+			assetdir = *assetdirFlag
+		}
+		if devServerFlag != nil {
+			devServer = *devServerFlag
+		}
+		if frontendDevServerURLFlag != nil {
+			frontendDevServerURL = *frontendDevServerURLFlag
+		}
+		if loglevelFlag != nil {
+			loglevel = *loglevelFlag
+		}
+	}
+
+	assetConfig, err := assetserver.BuildAssetServerConfig(appoptions)
+	if err != nil {
+		return nil, err
+	}
+
+	if assetConfig.Assets == nil && frontendDevServerURL != "" {
+		myLogger.Warning("No AssetServer.Assets has been defined but a frontend DevServer, the frontend DevServer will not be used.")
+		frontendDevServerURL = ""
+		assetdir = ""
+	}
+
+	if frontendDevServerURL != "" {
+		_, port, err := net.SplitHostPort(devServer)
+		if err != nil {
+			return nil, fmt.Errorf("unable to determine port of DevServer: %s", err)
+		}
+
+		ctx = context.WithValue(ctx, "assetserverport", port)
+
+		ctx = context.WithValue(ctx, "frontenddevserverurl", frontendDevServerURL)
+
+		externalURL, err := url.Parse(frontendDevServerURL)
+		if err != nil {
+			return nil, err
+		}
+
+		if externalURL.Host == "" {
+			return nil, fmt.Errorf("Invalid frontend:dev:serverUrl missing protocol scheme?")
+		}
+
+		waitCb := func() { myLogger.Debug("Waiting for frontend DevServer '%s' to be ready", externalURL) }
+		if !checkPortIsOpen(externalURL.Host, time.Minute, waitCb) {
+			myLogger.Error("Timeout waiting for frontend DevServer")
+		}
+
+		handler := assetserver.NewExternalAssetsHandler(myLogger, assetConfig, externalURL)
+		assetConfig.Assets = nil
+		assetConfig.Handler = handler
+		assetConfig.Middleware = nil
+
+		myLogger.Info("Serving assets from frontend DevServer URL: %s", frontendDevServerURL)
+	} else {
+		if assetdir == "" {
+			// If no assetdir has been defined, let's try to infer it from the project root and the asset FS.
+			assetdir, err = tryInferAssetDirFromFS(assetConfig.Assets)
+			if err != nil {
+				return nil, fmt.Errorf("unable to infer the AssetDir from your Assets fs.FS: %w", err)
+			}
+		}
+
+		if assetdir != "" {
+			// Let's override the assets to serve from on disk, if needed
+			absdir, err := filepath.Abs(assetdir)
+			if err != nil {
+				return nil, err
+			}
+
+			myLogger.Info("Serving assets from disk: %s", absdir)
+			assetConfig.Assets = os.DirFS(absdir)
+
+			ctx = context.WithValue(ctx, "assetdir", assetdir)
+		}
+	}
+
+	// Migrate deprecated options to the new AssetServer option
+	appoptions.Assets = nil
+	appoptions.AssetsHandler = nil
+	appoptions.AssetServer = &assetConfig
+
+	if devServer != "" {
+		ctx = context.WithValue(ctx, "devserver", devServer)
+	}
+
+	if loglevel != "" {
+		level, err := pkglogger.StringToLogLevel(loglevel)
+		if err != nil {
+			return nil, err
+		}
+		// Only set the log level if it's different from the appoptions.LogLevel
+		if level != appoptions.LogLevel {
+			myLogger.SetLogLevel(level)
+		}
+	}
+
+	// Attach logger to context
+	ctx = context.WithValue(ctx, "logger", myLogger)
+	ctx = context.WithValue(ctx, "buildtype", "dev")
+
+	// Preflight checks
+	err = PreflightChecks(appoptions, myLogger)
+	if err != nil {
+		return nil, err
+	}
+
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	var menuManager *menumanager.Manager
+
+	// Process the application menu
+	if appoptions.Menu != nil {
+		// Create the menu manager
+		menuManager = menumanager.NewManager()
+		err = menuManager.SetApplicationMenu(appoptions.Menu)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{
+		appoptions.OnStartup,
+		appoptions.OnShutdown,
+		appoptions.OnDomReady,
+		appoptions.OnBeforeClose,
+	}
+	appBindings := binding.NewBindings(myLogger, appoptions.Bind, bindingExemptions, false, appoptions.EnumBind)
+
+	eventHandler := runtime.NewEvents(myLogger)
+	ctx = context.WithValue(ctx, "events", eventHandler)
+	messageDispatcher := dispatcher.NewDispatcher(ctx, myLogger, appBindings, eventHandler, appoptions.ErrorFormatter, appoptions.DisablePanicRecovery)
+
+	// Create the frontends and register to event handler
+	desktopFrontend := desktop.NewFrontend(ctx, appoptions, myLogger, appBindings, messageDispatcher)
+	appFrontend := devserver.NewFrontend(ctx, appoptions, myLogger, appBindings, messageDispatcher, menuManager, desktopFrontend)
+	eventHandler.AddFrontend(appFrontend)
+	eventHandler.AddFrontend(desktopFrontend)
+
+	ctx = context.WithValue(ctx, "frontend", appFrontend)
+	result := &App{
+		ctx:              ctx,
+		frontend:         appFrontend,
+		logger:           myLogger,
+		menuManager:      menuManager,
+		startupCallback:  appoptions.OnStartup,
+		shutdownCallback: appoptions.OnShutdown,
+		debug:            true,
+		devtoolsEnabled:  true,
+	}
+
+	result.options = appoptions
+
+	return result, nil
+
+}
+
+func tryInferAssetDirFromFS(assets iofs.FS) (string, error) {
+	if _, isEmbedFs := assets.(embed.FS); !isEmbedFs {
+		// We only infer the assetdir for embed.FS assets
+		return "", nil
+	}
+
+	path, err := fs.FindPathToFile(assets, "index.html")
+	if err != nil {
+		return "", err
+	}
+
+	path, err = filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+
+	if _, err := os.Stat(filepath.Join(path, "index.html")); err != nil {
+		if os.IsNotExist(err) {
+			err = fmt.Errorf(
+				"inferred assetdir '%s' does not exist or does not contain an 'index.html' file, "+
+					"please specify it with -assetdir or set it in wails.json",
+				path)
+		}
+		return "", err
+	}
+
+	return path, nil
+}
+
+func checkPortIsOpen(host string, timeout time.Duration, waitCB func()) (ret bool) {
+	if timeout == 0 {
+		timeout = time.Minute
+	}
+
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		conn, _ := net.DialTimeout("tcp", host, 2*time.Second)
+		if conn != nil {
+			conn.Close()
+			return true
+		}
+
+		waitCB()
+		time.Sleep(1 * time.Second)
+	}
+	return false
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_devtools.go

@@ -0,0 +1,8 @@
+//go:build devtools
+
+package app
+
+// Note: devtools flag is also added in debug builds
+func IsDevtoolsEnabled() bool {
+	return true
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_devtools_not.go

@@ -0,0 +1,9 @@
+//go:build !devtools
+
+package app
+
+// IsDevtoolsEnabled returns true if devtools should be enabled
+// Note: devtools flag is also added in debug builds
+func IsDevtoolsEnabled() bool {
+	return false
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_obfuscated.go

@@ -0,0 +1,8 @@
+//go:build obfuscated
+
+package app
+
+// IsObfuscated returns true if the obfuscated build tag is set
+func IsObfuscated() bool {
+	return true
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_obfuscated_not.go

@@ -0,0 +1,8 @@
+//go:build !obfuscated
+
+package app
+
+// IsObfuscated returns false if the obfuscated build tag is not set
+func IsObfuscated() bool {
+	return false
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_preflight_unix.go

@@ -0,0 +1,12 @@
+//go:build (linux || darwin) && !bindings
+
+package app
+
+import (
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func PreflightChecks(_ *options.App, _ *logger.Logger) error {
+	return nil
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_preflight_windows.go

@@ -0,0 +1,27 @@
+//go:build windows && !bindings
+
+package app
+
+import (
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/wv2installer"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func PreflightChecks(options *options.App, logger *logger.Logger) error {
+
+	_ = options
+
+	// Process the webview2 runtime situation. We can pass a strategy in via the `webview2` flag for `wails build`.
+	// This will determine how wv2runtime.Process will handle a lack of valid runtime.
+	installedVersion, err := wv2installer.Process(options)
+	if installedVersion != "" {
+		logger.Debug("WebView2 Runtime Version '%s' installed. Minimum version required: %s.",
+			installedVersion, wv2installer.MinimumRuntimeVersion)
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

vendor/github.com/wailsapp/wails/v2/internal/app/app_production.go

@@ -0,0 +1,104 @@
+//go:build production
+
+package app
+
+import (
+	"context"
+
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/frontend/desktop"
+	"github.com/wailsapp/wails/v2/internal/frontend/dispatcher"
+	"github.com/wailsapp/wails/v2/internal/frontend/runtime"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/menumanager"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *App) Run() error {
+	err := a.frontend.Run(a.ctx)
+	a.frontend.RunMainLoop()
+	a.frontend.WindowClose()
+	if a.shutdownCallback != nil {
+		a.shutdownCallback(a.ctx)
+	}
+	return err
+}
+
+// CreateApp creates the app!
+func CreateApp(appoptions *options.App) (*App, error) {
+	var err error
+
+	ctx := context.Background()
+
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	debug := IsDebug()
+	devtoolsEnabled := IsDevtoolsEnabled()
+	ctx = context.WithValue(ctx, "debug", debug)
+	ctx = context.WithValue(ctx, "devtoolsEnabled", devtoolsEnabled)
+
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	if IsDebug() {
+		myLogger.SetLogLevel(appoptions.LogLevel)
+	} else {
+		myLogger.SetLogLevel(appoptions.LogLevelProduction)
+	}
+	ctx = context.WithValue(ctx, "logger", myLogger)
+	ctx = context.WithValue(ctx, "obfuscated", IsObfuscated())
+
+	// Preflight Checks
+	err = PreflightChecks(appoptions, myLogger)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create the menu manager
+	menuManager := menumanager.NewManager()
+
+	// Process the application menu
+	if appoptions.Menu != nil {
+		err = menuManager.SetApplicationMenu(appoptions.Menu)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Create binding exemptions - Ugly hack. There must be a better way
+	bindingExemptions := []interface{}{
+		appoptions.OnStartup,
+		appoptions.OnShutdown,
+		appoptions.OnDomReady,
+		appoptions.OnBeforeClose,
+	}
+	appBindings := binding.NewBindings(myLogger, appoptions.Bind, bindingExemptions, IsObfuscated(), appoptions.EnumBind)
+	eventHandler := runtime.NewEvents(myLogger)
+	ctx = context.WithValue(ctx, "events", eventHandler)
+	// Attach logger to context
+	if debug {
+		ctx = context.WithValue(ctx, "buildtype", "debug")
+	} else {
+		ctx = context.WithValue(ctx, "buildtype", "production")
+	}
+
+	messageDispatcher := dispatcher.NewDispatcher(ctx, myLogger, appBindings, eventHandler, appoptions.ErrorFormatter, appoptions.DisablePanicRecovery)
+	appFrontend := desktop.NewFrontend(ctx, appoptions, myLogger, appBindings, messageDispatcher)
+	eventHandler.AddFrontend(appFrontend)
+
+	ctx = context.WithValue(ctx, "frontend", appFrontend)
+	result := &App{
+		ctx:              ctx,
+		frontend:         appFrontend,
+		logger:           myLogger,
+		menuManager:      menuManager,
+		startupCallback:  appoptions.OnStartup,
+		shutdownCallback: appoptions.OnShutdown,
+		debug:            debug,
+		devtoolsEnabled:  devtoolsEnabled,
+		options:          appoptions,
+	}
+
+	return result, nil
+
+}