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/logger/custom_logger.go

@@ -0,0 +1,95 @@
+package logger
+
+import (
+	"fmt"
+)
+
+// CustomLogger defines what a user can do with a logger
+type CustomLogger interface {
+	// Writeln writes directly to the output with no log level plus line ending
+	Writeln(message string)
+
+	// Write writes directly to the output with no log level
+	Write(message string)
+
+	// Trace level logging. Works like Sprintf.
+	Trace(format string, args ...interface{})
+
+	// Debug level logging. Works like Sprintf.
+	Debug(format string, args ...interface{})
+
+	// Info level logging. Works like Sprintf.
+	Info(format string, args ...interface{})
+
+	// Warning level logging. Works like Sprintf.
+	Warning(format string, args ...interface{})
+
+	// Error level logging. Works like Sprintf.
+	Error(format string, args ...interface{})
+
+	// Fatal level logging. Works like Sprintf.
+	Fatal(format string, args ...interface{})
+}
+
+// customLogger is a utlility to log messages to a number of destinations
+type customLogger struct {
+	logger *Logger
+	name   string
+}
+
+// New creates a new customLogger. You may pass in a number of `io.Writer`s that
+// are the targets for the logs
+func newcustomLogger(logger *Logger, name string) *customLogger {
+	result := &customLogger{
+		name:   name,
+		logger: logger,
+	}
+	return result
+}
+
+// Writeln writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *customLogger) Writeln(message string) {
+	l.logger.Writeln(message)
+}
+
+// Write writes directly to the output with no log level
+func (l *customLogger) Write(message string) {
+	l.logger.Write(message)
+}
+
+// Trace level logging. Works like Sprintf.
+func (l *customLogger) Trace(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Trace(format, args...)
+}
+
+// Debug level logging. Works like Sprintf.
+func (l *customLogger) Debug(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Debug(format, args...)
+}
+
+// Info level logging. Works like Sprintf.
+func (l *customLogger) Info(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Info(format, args...)
+}
+
+// Warning level logging. Works like Sprintf.
+func (l *customLogger) Warning(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Warning(format, args...)
+}
+
+// Error level logging. Works like Sprintf.
+func (l *customLogger) Error(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Error(format, args...)
+}
+
+// Fatal level logging. Works like Sprintf.
+func (l *customLogger) Fatal(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Fatal(format, args...)
+}

vendor/github.com/wailsapp/wails/v2/internal/logger/default_logger.go

@@ -0,0 +1,107 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
+)
+
+// LogLevel is an alias for the public LogLevel
+type LogLevel = logger.LogLevel
+
+// Logger is a utlility to log messages to a number of destinations
+type Logger struct {
+	output         logger.Logger
+	logLevel       LogLevel
+	showLevelInLog bool
+}
+
+// New creates a new Logger. You may pass in a number of `io.Writer`s that
+// are the targets for the logs
+func New(output logger.Logger) *Logger {
+	if output == nil {
+		output = logger.NewDefaultLogger()
+	}
+	result := &Logger{
+		logLevel:       logger.INFO,
+		showLevelInLog: true,
+		output:         output,
+	}
+
+	return result
+}
+
+// CustomLogger creates a new custom logger that prints out a name/id
+// before the messages
+func (l *Logger) CustomLogger(name string) CustomLogger {
+	return newcustomLogger(l, name)
+}
+
+// HideLogLevel removes the loglevel text from the start of each logged line
+func (l *Logger) HideLogLevel() {
+	l.showLevelInLog = true
+}
+
+// SetLogLevel sets the minimum level of logs that will be output
+func (l *Logger) SetLogLevel(level LogLevel) {
+	l.logLevel = level
+}
+
+// Writeln writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *Logger) Writeln(message string) {
+	l.output.Print(message)
+}
+
+// Write writes directly to the output with no log level
+func (l *Logger) Write(message string) {
+	l.output.Print(message)
+}
+
+// Print writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *Logger) Print(message string) {
+	l.Write(message)
+}
+
+// Trace level logging. Works like Sprintf.
+func (l *Logger) Trace(format string, args ...interface{}) {
+	if l.logLevel <= logger.TRACE {
+		l.output.Trace(fmt.Sprintf(format, args...))
+	}
+}
+
+// Debug level logging. Works like Sprintf.
+func (l *Logger) Debug(format string, args ...interface{}) {
+	if l.logLevel <= logger.DEBUG {
+		l.output.Debug(fmt.Sprintf(format, args...))
+	}
+}
+
+// Info level logging. Works like Sprintf.
+func (l *Logger) Info(format string, args ...interface{}) {
+	if l.logLevel <= logger.INFO {
+		l.output.Info(fmt.Sprintf(format, args...))
+	}
+}
+
+// Warning level logging. Works like Sprintf.
+func (l *Logger) Warning(format string, args ...interface{}) {
+	if l.logLevel <= logger.WARNING {
+		l.output.Warning(fmt.Sprintf(format, args...))
+	}
+}
+
+// Error level logging. Works like Sprintf.
+func (l *Logger) Error(format string, args ...interface{}) {
+	if l.logLevel <= logger.ERROR {
+		l.output.Error(fmt.Sprintf(format, args...))
+	}
+}
+
+// Fatal level logging. Works like Sprintf.
+func (l *Logger) Fatal(format string, args ...interface{}) {
+	l.output.Fatal(fmt.Sprintf(format, args...))
+	os.Exit(1)
+}