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/menumanager/applicationmenu.go

@@ -0,0 +1,49 @@
+package menumanager
+
+import "github.com/wailsapp/wails/v2/pkg/menu"
+
+func (m *Manager) SetApplicationMenu(applicationMenu *menu.Menu) error {
+	if applicationMenu == nil {
+		return nil
+	}
+
+	m.applicationMenu = applicationMenu
+
+	// Reset the menu map
+	m.applicationMenuItemMap = NewMenuItemMap()
+
+	// Add the menu to the menu map
+	m.applicationMenuItemMap.AddMenu(applicationMenu)
+
+	return m.processApplicationMenu()
+}
+
+func (m *Manager) GetApplicationMenuJSON() string {
+	return m.applicationMenuJSON
+}
+
+func (m *Manager) GetProcessedApplicationMenu() *WailsMenu {
+	return m.processedApplicationMenu
+}
+
+// UpdateApplicationMenu reprocesses the application menu to pick up structure
+// changes etc
+// Returns the JSON representation of the updated menu
+func (m *Manager) UpdateApplicationMenu() (string, error) {
+	m.applicationMenuItemMap = NewMenuItemMap()
+	m.applicationMenuItemMap.AddMenu(m.applicationMenu)
+	err := m.processApplicationMenu()
+	return m.applicationMenuJSON, err
+}
+
+func (m *Manager) processApplicationMenu() error {
+	// Process the menu
+	m.processedApplicationMenu = NewWailsMenu(m.applicationMenuItemMap, m.applicationMenu)
+	m.processRadioGroups(m.processedApplicationMenu, m.applicationMenuItemMap)
+	applicationMenuJSON, err := m.processedApplicationMenu.AsJSON()
+	if err != nil {
+		return err
+	}
+	m.applicationMenuJSON = applicationMenuJSON
+	return nil
+}

vendor/github.com/wailsapp/wails/v2/internal/menumanager/contextmenu.go

@@ -0,0 +1,59 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type ContextMenu struct {
+	ID            string
+	ProcessedMenu *WailsMenu
+	menuItemMap   *MenuItemMap
+	menu          *menu.Menu
+}
+
+func (t *ContextMenu) AsJSON() (string, error) {
+	data, err := json.Marshal(t)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func NewContextMenu(contextMenu *menu.ContextMenu) *ContextMenu {
+	result := &ContextMenu{
+		ID:          contextMenu.ID,
+		menu:        contextMenu.Menu,
+		menuItemMap: NewMenuItemMap(),
+	}
+
+	result.menuItemMap.AddMenu(contextMenu.Menu)
+	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
+
+	return result
+}
+
+func (m *Manager) AddContextMenu(contextMenu *menu.ContextMenu) {
+	newContextMenu := NewContextMenu(contextMenu)
+
+	// Save the references
+	m.contextMenus[contextMenu.ID] = newContextMenu
+	m.contextMenuPointers[contextMenu] = contextMenu.ID
+}
+
+func (m *Manager) UpdateContextMenu(contextMenu *menu.ContextMenu) (string, error) {
+	contextMenuID, contextMenuKnown := m.contextMenuPointers[contextMenu]
+	if !contextMenuKnown {
+		return "", fmt.Errorf("unknown Context Menu '%s'. Please add the context menu using AddContextMenu()", contextMenu.ID)
+	}
+
+	// Create the updated context menu
+	updatedContextMenu := NewContextMenu(contextMenu)
+
+	// Save the reference
+	m.contextMenus[contextMenuID] = updatedContextMenu
+
+	return updatedContextMenu.AsJSON()
+}

vendor/github.com/wailsapp/wails/v2/internal/menumanager/menuitemmap.go

@@ -0,0 +1,76 @@
+package menumanager
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+// MenuItemMap holds a mapping between menuIDs and menu items
+type MenuItemMap struct {
+	idToMenuItemMap map[string]*menu.MenuItem
+	menuItemToIDMap map[*menu.MenuItem]string
+
+	// We use a simple counter to keep track of unique menu IDs
+	menuIDCounter      int64
+	menuIDCounterMutex sync.Mutex
+}
+
+func NewMenuItemMap() *MenuItemMap {
+	result := &MenuItemMap{
+		idToMenuItemMap: make(map[string]*menu.MenuItem),
+		menuItemToIDMap: make(map[*menu.MenuItem]string),
+	}
+
+	return result
+}
+
+func (m *MenuItemMap) AddMenu(menu *menu.Menu) {
+	if menu == nil {
+		return
+	}
+	for _, item := range menu.Items {
+		m.processMenuItem(item)
+	}
+}
+
+func (m *MenuItemMap) Dump() {
+	println("idToMenuItemMap:")
+	for key, value := range m.idToMenuItemMap {
+		fmt.Printf("  %s\t%p\n", key, value)
+	}
+	println("\nmenuItemToIDMap")
+	for key, value := range m.menuItemToIDMap {
+		fmt.Printf("  %p\t%s\n", key, value)
+	}
+}
+
+// GenerateMenuID returns a unique string ID for a menu item
+func (m *MenuItemMap) generateMenuID() string {
+	m.menuIDCounterMutex.Lock()
+	result := strconv.FormatInt(m.menuIDCounter, 10)
+	m.menuIDCounter++
+	m.menuIDCounterMutex.Unlock()
+	return result
+}
+
+func (m *MenuItemMap) processMenuItem(item *menu.MenuItem) {
+	if item.SubMenu != nil {
+		for _, submenuitem := range item.SubMenu.Items {
+			m.processMenuItem(submenuitem)
+		}
+	}
+
+	// Create a unique ID for this menu item
+	menuID := m.generateMenuID()
+
+	// Store references
+	m.idToMenuItemMap[menuID] = item
+	m.menuItemToIDMap[item] = menuID
+}
+
+func (m *MenuItemMap) getMenuItemByID(menuId string) *menu.MenuItem {
+	return m.idToMenuItemMap[menuId]
+}

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

@@ -0,0 +1,115 @@
+package menumanager
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+type Manager struct {
+	// The application menu.
+	applicationMenu          *menu.Menu
+	applicationMenuJSON      string
+	processedApplicationMenu *WailsMenu
+
+	// Our application menu mappings
+	applicationMenuItemMap *MenuItemMap
+
+	// Context menus
+	contextMenus        map[string]*ContextMenu
+	contextMenuPointers map[*menu.ContextMenu]string
+
+	// Tray menu stores
+	trayMenus        map[string]*TrayMenu
+	trayMenuPointers map[*menu.TrayMenu]string
+
+	// Radio groups
+	radioGroups map[*menu.MenuItem][]*menu.MenuItem
+}
+
+func NewManager() *Manager {
+	return &Manager{
+		applicationMenuItemMap: NewMenuItemMap(),
+		contextMenus:           make(map[string]*ContextMenu),
+		contextMenuPointers:    make(map[*menu.ContextMenu]string),
+		trayMenus:              make(map[string]*TrayMenu),
+		trayMenuPointers:       make(map[*menu.TrayMenu]string),
+		radioGroups:            make(map[*menu.MenuItem][]*menu.MenuItem),
+	}
+}
+
+func (m *Manager) getMenuItemByID(menuMap *MenuItemMap, menuId string) *menu.MenuItem {
+	return menuMap.idToMenuItemMap[menuId]
+}
+
+func (m *Manager) ProcessClick(menuID string, data string, menuType string, parentID string) error {
+	var menuItemMap *MenuItemMap
+
+	switch menuType {
+	case "ApplicationMenu":
+		menuItemMap = m.applicationMenuItemMap
+	case "ContextMenu":
+		contextMenu := m.contextMenus[parentID]
+		if contextMenu == nil {
+			return fmt.Errorf("unknown context menu: %s", parentID)
+		}
+		menuItemMap = contextMenu.menuItemMap
+	case "TrayMenu":
+		trayMenu := m.trayMenus[parentID]
+		if trayMenu == nil {
+			return fmt.Errorf("unknown tray menu: %s", parentID)
+		}
+		menuItemMap = trayMenu.menuItemMap
+	default:
+		return fmt.Errorf("unknown menutype: %s", menuType)
+	}
+
+	// Get the menu item
+	menuItem := menuItemMap.getMenuItemByID(menuID)
+	if menuItem == nil {
+		return fmt.Errorf("Cannot process menuid %s - unknown", menuID)
+	}
+
+	// Is the menu item a checkbox?
+	if menuItem.Type == menu.CheckboxType {
+		// Toggle state
+		menuItem.Checked = !menuItem.Checked
+	}
+
+	if menuItem.Type == menu.RadioType {
+		println("Toggle radio")
+		// Get my radio group
+		for _, radioMenuItem := range m.radioGroups[menuItem] {
+			radioMenuItem.Checked = (radioMenuItem == menuItem)
+		}
+	}
+
+	if menuItem.Click == nil {
+		// No callback
+		return fmt.Errorf("No callback for menu '%s'", menuItem.Label)
+	}
+
+	// Create new Callback struct
+	callbackData := &menu.CallbackData{
+		MenuItem: menuItem,
+		// ContextData: data,
+	}
+
+	// Call back!
+	go menuItem.Click(callbackData)
+
+	return nil
+}
+
+func (m *Manager) processRadioGroups(processedMenu *WailsMenu, itemMap *MenuItemMap) {
+	for _, group := range processedMenu.RadioGroups {
+		radioGroupMenuItems := []*menu.MenuItem{}
+		for _, member := range group.Members {
+			item := m.getMenuItemByID(itemMap, member)
+			radioGroupMenuItems = append(radioGroupMenuItems, item)
+		}
+		for _, radioGroupMenuItem := range radioGroupMenuItems {
+			m.radioGroups[radioGroupMenuItem] = radioGroupMenuItems
+		}
+	}
+}

vendor/github.com/wailsapp/wails/v2/internal/menumanager/processedMenu.go

@@ -0,0 +1,185 @@
+package menumanager
+
+import (
+	"encoding/json"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/menu/keys"
+)
+
+type ProcessedMenuItem struct {
+	ID string
+	// Label is what appears as the menu text
+	Label string `json:",omitempty"`
+	// Role is a predefined menu type
+	// Role menu.Role `json:",omitempty"`
+	// Accelerator holds a representation of a key binding
+	Accelerator *keys.Accelerator `json:",omitempty"`
+	// Type of MenuItem, EG: Checkbox, Text, Separator, Radio, Submenu
+	Type menu.Type
+	// Disabled makes the item unselectable
+	Disabled bool `json:",omitempty"`
+	// Hidden ensures that the item is not shown in the menu
+	Hidden bool `json:",omitempty"`
+	// Checked indicates if the item is selected (used by Checkbox and Radio types only)
+	Checked bool `json:",omitempty"`
+	// SubMenu contains a list of menu items that will be shown as a submenu
+	// SubMenu []*MenuItem `json:"SubMenu,omitempty"`
+	SubMenu *ProcessedMenu `json:",omitempty"`
+	/*
+		// Colour
+		RGBA string `json:",omitempty"`
+
+		// Font
+		FontSize int    `json:",omitempty"`
+		FontName string `json:",omitempty"`
+
+		// Image - base64 image data
+		Image            string `json:",omitempty"`
+		MacTemplateImage bool   `json:", omitempty"`
+		MacAlternate     bool   `json:", omitempty"`
+
+		// Tooltip
+		Tooltip string `json:",omitempty"`
+
+		// Styled label
+		StyledLabel []*ansi.StyledText `json:",omitempty"`
+	*/
+}
+
+func NewProcessedMenuItem(menuItemMap *MenuItemMap, menuItem *menu.MenuItem) *ProcessedMenuItem {
+	ID := menuItemMap.menuItemToIDMap[menuItem]
+
+	// Parse ANSI text
+	//var styledLabel []*ansi.StyledText
+	//tempLabel := menuItem.Label
+	//if strings.Contains(tempLabel, "\033[") {
+	//	parsedLabel, err := ansi.Parse(menuItem.Label)
+	//	if err == nil {
+	//		styledLabel = parsedLabel
+	//	}
+	//}
+
+	result := &ProcessedMenuItem{
+		ID:    ID,
+		Label: menuItem.Label,
+		// Role:             menuItem.Role,
+		Accelerator: menuItem.Accelerator,
+		Type:        menuItem.Type,
+		Disabled:    menuItem.Disabled,
+		Hidden:      menuItem.Hidden,
+		Checked:     menuItem.Checked,
+		SubMenu:     nil,
+		// BackgroundColour:             menuItem.BackgroundColour,
+		// FontSize:         menuItem.FontSize,
+		// FontName:         menuItem.FontName,
+		// Image:            menuItem.Image,
+		// MacTemplateImage: menuItem.MacTemplateImage,
+		// MacAlternate:     menuItem.MacAlternate,
+		// Tooltip:          menuItem.Tooltip,
+		// StyledLabel:      styledLabel,
+	}
+
+	if menuItem.SubMenu != nil {
+		result.SubMenu = NewProcessedMenu(menuItemMap, menuItem.SubMenu)
+	}
+
+	return result
+}
+
+type ProcessedMenu struct {
+	Items []*ProcessedMenuItem
+}
+
+func NewProcessedMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *ProcessedMenu {
+	result := &ProcessedMenu{}
+	if menu != nil {
+		for _, item := range menu.Items {
+			processedMenuItem := NewProcessedMenuItem(menuItemMap, item)
+			result.Items = append(result.Items, processedMenuItem)
+		}
+	}
+
+	return result
+}
+
+// WailsMenu is the original menu with the addition
+// of radio groups extracted from the menu data
+type WailsMenu struct {
+	Menu              *ProcessedMenu
+	RadioGroups       []*RadioGroup
+	currentRadioGroup []string
+}
+
+// RadioGroup holds all the members of the same radio group
+type RadioGroup struct {
+	Members []string
+	Length  int
+}
+
+func NewWailsMenu(menuItemMap *MenuItemMap, menu *menu.Menu) *WailsMenu {
+	result := &WailsMenu{}
+
+	// Process the menus
+	result.Menu = NewProcessedMenu(menuItemMap, menu)
+
+	// Process the radio groups
+	result.processRadioGroups()
+
+	return result
+}
+
+func (w *WailsMenu) AsJSON() (string, error) {
+	menuAsJSON, err := json.Marshal(w)
+	if err != nil {
+		return "", err
+	}
+	return string(menuAsJSON), nil
+}
+
+func (w *WailsMenu) processRadioGroups() {
+	// Loop over top level menus
+	for _, item := range w.Menu.Items {
+		// Process MenuItem
+		w.processMenuItem(item)
+	}
+
+	w.finaliseRadioGroup()
+}
+
+func (w *WailsMenu) processMenuItem(item *ProcessedMenuItem) {
+	switch item.Type {
+
+	// We need to recurse submenus
+	case menu.SubmenuType:
+
+		// Finalise any current radio groups as they don't trickle down to submenus
+		w.finaliseRadioGroup()
+
+		// Process each submenu item
+		for _, subitem := range item.SubMenu.Items {
+			w.processMenuItem(subitem)
+		}
+	case menu.RadioType:
+		// Add the item to the radio group
+		w.currentRadioGroup = append(w.currentRadioGroup, item.ID)
+	default:
+		w.finaliseRadioGroup()
+	}
+}
+
+func (w *WailsMenu) finaliseRadioGroup() {
+	// If we were processing a radio group, fix up the references
+	if len(w.currentRadioGroup) > 0 {
+
+		// Create new radiogroup
+		group := &RadioGroup{
+			Members: w.currentRadioGroup,
+			Length:  len(w.currentRadioGroup),
+		}
+		w.RadioGroups = append(w.RadioGroups, group)
+
+		// Empty the radio group
+		w.currentRadioGroup = []string{}
+	}
+}

vendor/github.com/wailsapp/wails/v2/internal/menumanager/traymenu.go

@@ -0,0 +1,222 @@
+package menumanager
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/leaanthony/go-ansi-parser"
+
+	"github.com/pkg/errors"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+var (
+	trayMenuID      int
+	trayMenuIDMutex sync.Mutex
+)
+
+func generateTrayID() string {
+	var idStr string
+	trayMenuIDMutex.Lock()
+	idStr = strconv.Itoa(trayMenuID)
+	trayMenuID++
+	trayMenuIDMutex.Unlock()
+	return idStr
+}
+
+type TrayMenu struct {
+	ID               string
+	Label            string
+	FontSize         int
+	FontName         string
+	Disabled         bool
+	Tooltip          string `json:",omitempty"`
+	Image            string
+	MacTemplateImage bool
+	RGBA             string
+	menuItemMap      *MenuItemMap
+	menu             *menu.Menu
+	ProcessedMenu    *WailsMenu
+	trayMenu         *menu.TrayMenu
+	StyledLabel      []*ansi.StyledText `json:",omitempty"`
+}
+
+func (t *TrayMenu) AsJSON() (string, error) {
+	data, err := json.Marshal(t)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func NewTrayMenu(trayMenu *menu.TrayMenu) *TrayMenu {
+	// Parse ANSI text
+	var styledLabel []*ansi.StyledText
+	tempLabel := trayMenu.Label
+	if strings.Contains(tempLabel, "\033[") {
+		parsedLabel, err := ansi.Parse(tempLabel)
+		if err == nil {
+			styledLabel = parsedLabel
+		}
+	}
+
+	result := &TrayMenu{
+		Label:            trayMenu.Label,
+		FontName:         trayMenu.FontName,
+		FontSize:         trayMenu.FontSize,
+		Disabled:         trayMenu.Disabled,
+		Tooltip:          trayMenu.Tooltip,
+		Image:            trayMenu.Image,
+		MacTemplateImage: trayMenu.MacTemplateImage,
+		menu:             trayMenu.Menu,
+		RGBA:             trayMenu.RGBA,
+		menuItemMap:      NewMenuItemMap(),
+		trayMenu:         trayMenu,
+		StyledLabel:      styledLabel,
+	}
+
+	result.menuItemMap.AddMenu(trayMenu.Menu)
+	result.ProcessedMenu = NewWailsMenu(result.menuItemMap, result.menu)
+
+	return result
+}
+
+func (m *Manager) OnTrayMenuOpen(id string) {
+	trayMenu, ok := m.trayMenus[id]
+	if !ok {
+		return
+	}
+	if trayMenu.trayMenu.OnOpen == nil {
+		return
+	}
+	go trayMenu.trayMenu.OnOpen()
+}
+
+func (m *Manager) OnTrayMenuClose(id string) {
+	trayMenu, ok := m.trayMenus[id]
+	if !ok {
+		return
+	}
+	if trayMenu.trayMenu.OnClose == nil {
+		return
+	}
+	go trayMenu.trayMenu.OnClose()
+}
+
+func (m *Manager) AddTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
+	newTrayMenu := NewTrayMenu(trayMenu)
+
+	// Hook up a new ID
+	trayID := generateTrayID()
+	newTrayMenu.ID = trayID
+
+	// Save the references
+	m.trayMenus[trayID] = newTrayMenu
+	m.trayMenuPointers[trayMenu] = trayID
+
+	return newTrayMenu.AsJSON()
+}
+
+func (m *Manager) GetTrayID(trayMenu *menu.TrayMenu) (string, error) {
+	trayID, exists := m.trayMenuPointers[trayMenu]
+	if !exists {
+		return "", fmt.Errorf("Unable to find menu ID for tray menu!")
+	}
+	return trayID, nil
+}
+
+// SetTrayMenu updates or creates a menu
+func (m *Manager) SetTrayMenu(trayMenu *menu.TrayMenu) (string, error) {
+	trayID, trayMenuKnown := m.trayMenuPointers[trayMenu]
+	if !trayMenuKnown {
+		return m.AddTrayMenu(trayMenu)
+	}
+
+	// Create the updated tray menu
+	updatedTrayMenu := NewTrayMenu(trayMenu)
+	updatedTrayMenu.ID = trayID
+
+	// Save the reference
+	m.trayMenus[trayID] = updatedTrayMenu
+
+	return updatedTrayMenu.AsJSON()
+}
+
+func (m *Manager) GetTrayMenus() ([]string, error) {
+	result := []string{}
+	for _, trayMenu := range m.trayMenus {
+		JSON, err := trayMenu.AsJSON()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, JSON)
+	}
+
+	return result, nil
+}
+
+func (m *Manager) UpdateTrayMenuLabel(trayMenu *menu.TrayMenu) (string, error) {
+	trayID, trayMenuKnown := m.trayMenuPointers[trayMenu]
+	if !trayMenuKnown {
+		return "", fmt.Errorf("[UpdateTrayMenuLabel] unknown tray id for tray %s", trayMenu.Label)
+	}
+
+	type LabelUpdate struct {
+		ID               string
+		Label            string `json:",omitempty"`
+		FontName         string `json:",omitempty"`
+		FontSize         int
+		RGBA             string `json:",omitempty"`
+		Disabled         bool
+		Tooltip          string `json:",omitempty"`
+		Image            string `json:",omitempty"`
+		MacTemplateImage bool
+		StyledLabel      []*ansi.StyledText `json:",omitempty"`
+	}
+
+	// Parse ANSI text
+	var styledLabel []*ansi.StyledText
+	tempLabel := trayMenu.Label
+	if strings.Contains(tempLabel, "\033[") {
+		parsedLabel, err := ansi.Parse(tempLabel)
+		if err == nil {
+			styledLabel = parsedLabel
+		}
+	}
+
+	update := &LabelUpdate{
+		ID:               trayID,
+		Label:            trayMenu.Label,
+		FontName:         trayMenu.FontName,
+		FontSize:         trayMenu.FontSize,
+		Disabled:         trayMenu.Disabled,
+		Tooltip:          trayMenu.Tooltip,
+		Image:            trayMenu.Image,
+		MacTemplateImage: trayMenu.MacTemplateImage,
+		RGBA:             trayMenu.RGBA,
+		StyledLabel:      styledLabel,
+	}
+
+	data, err := json.Marshal(update)
+	if err != nil {
+		return "", errors.Wrap(err, "[UpdateTrayMenuLabel] ")
+	}
+
+	return string(data), nil
+}
+
+func (m *Manager) GetContextMenus() ([]string, error) {
+	result := []string{}
+	for _, contextMenu := range m.contextMenus {
+		JSON, err := contextMenu.AsJSON()
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, JSON)
+	}
+
+	return result, nil
+}