Move executable.name destination to .app bundle resources on macOS

Author: denys-hrulov

pkg/common/binaries_settings.go pkg/common/executable_name_file.gopkg/common/binaries_settings.go renamed to pkg/common/executable_name_file.go

@@ -26,17 +26,25 @@ import (
 	"github.com/TeamDev-IP/Chromium-Branding/pkg/base"
 )
 
-// WriteExecutableName creates (or truncates) a file named "executable.name" inside
-// the provided binariesDir directory and writes the given executableName string into it.
-//
-// It returns an error if the file cannot be created or if writing to the file fails.
-func WriteExecutableName(executableName string, binariesDir base.Directory) error {
-	file, err := os.Create(binariesDir.AbsPath().Join(base.RelPathFromEntries("executable.name")).String())
+// ExecutableNameFile represents a file that holds the name of the main executable.
+// This file is named "executable.name" and is stored in a specific resources directory.
+type ExecutableNameFile struct {
+	// Location is the directory where the executable name file is to be located.
+	Location base.Directory
+	// Content is the name of the main executable to be written into the file.
+	Content string
+}
+
+// CreateOrUpdate creates or updates the executable name file in the specified location.
+// It writes the Content field to a file named "executable.name" inside the Location directory.
+// Returns an error if the file cannot be created or written to.
+func (executableName *ExecutableNameFile) CreateOrUpdate() error {
+	file, err := os.Create(executableName.Location.AbsPath().Join(base.RelPathFromEntries("executable.name")).String())
 	if err != nil {
 		return err
 	}
 	defer file.Close()
 
-	_, err = file.WriteString(executableName)
+	_, err = file.WriteString(executableName.Content)
 	return err
 }

pkg/core/branding.go

@@ -97,9 +97,10 @@ type PlatformBranding interface {
 	// according to the provided BrandingParams.
 	Apply(params *common.BrandingParams, binariesDir base.Directory) error
 
-	// ExecutableName returns the name of the main executable file,
-	// derived from the BrandingParams.
-	ExecutableName(params *common.BrandingParams) string
+	// ExecutableNameFile returns common.ExecutableNameFile for the Chromium binaries from the given
+	// binariesDir assuming they are branded with the given params.
+	// Returns an error if the file destination is invalid or cannot be determined.
+	ExecutableNameFile(params *common.BrandingParams, binariesDir base.Directory) (common.ExecutableNameFile, error)
 }
 
 // Branding wraps a set of BrandingParams and a PlatformBranding
@@ -150,9 +151,10 @@ func brandBinariesInDirectory(branding *Branding, params common.BrandingParams,
 	if err := branding.Apply(outputDir); err != nil {
 		return err
 	}
-	if err := common.WriteExecutableName(branding.platform.ExecutableName(&params), outputDir); err != nil {
-		return err
+	executableNameFile, err := branding.platform.ExecutableNameFile(&params, outputDir)
+	if err != nil {
+		return fmt.Errorf("the executable.name file destination is invalid: %w", err)
 	}
 
-	return nil
+	return executableNameFile.CreateOrUpdate()
 }

pkg/linux/branding.go

@@ -37,6 +37,13 @@ func GetPlatformBranding() (*LinuxBranding, error) {
 // LinuxBranding implements branding logic specific to Linux platforms.
 type LinuxBranding struct{}
 
+func (branding *LinuxBranding) ExecutableNameFile(params *common.BrandingParams, binariesDir base.Directory) (common.ExecutableNameFile, error) {
+	return common.ExecutableNameFile{
+		Location: binariesDir,
+		Content:  branding.ExecutableName(params),
+	}, nil
+}
+
 // ExecutableName returns the Linux process name from BrandingParams if set,
 // or defaults to "chromium" otherwise.
 func (branding *LinuxBranding) ExecutableName(params *common.BrandingParams) string {

pkg/mac/branding.go

@@ -99,6 +99,24 @@ func (branding *MacBranding) Apply(params *common.BrandingParams, binariesDir ba
 	return nil
 }
 
+func (branding *MacBranding) ExecutableNameFile(params *common.BrandingParams, binariesDir base.Directory) (common.ExecutableNameFile, error) {
+	executableName := branding.ExecutableName(params)
+	mainBundle, err := GetChromiumAppBundle(binariesDir, executableName)
+	if err != nil {
+		return common.ExecutableNameFile{}, err
+	}
+
+	resourcesDir, err := mainBundle.ChromiumAppBundle().Path().Join(base.RelPathFromEntries("Contents", "Resources")).AsDirectory()
+	if err != nil {
+		return common.ExecutableNameFile{}, err
+	}
+
+	return common.ExecutableNameFile{
+		Location: resourcesDir,
+		Content:  executableName,
+	}, nil
+}
+
 func (branding *MacBranding) ExecutableName(params *common.BrandingParams) string {
 	if params.Mac.Bundle.Name != nil {
 		return *params.Mac.Bundle.Name

pkg/win/branding.go

@@ -48,6 +48,13 @@ func GetPlatformBranding() (*WinBranding, error) {
 	}
 }
 
+func (branding *WinBranding) ExecutableNameFile(params *common.BrandingParams, binariesDir base.Directory) (common.ExecutableNameFile, error) {
+	return common.ExecutableNameFile{
+		Location: binariesDir,
+		Content:  branding.ExecutableName(params),
+	}, nil
+}
+
 // ExecutableName returns the user-specified Windows executable name
 // if set in BrandingParams, or falls back to original chromium executable name.
 func (branding *WinBranding) ExecutableName(params *common.BrandingParams) string {

pkg/win/unsigned_binary.go

@@ -43,9 +43,13 @@ func (unsignedBinary UnsignedBinary) AbsPath() base.AbsPath {
 	return unsignedBinary.File().AbsPath()
 }
 
-// File returns a pointer to the underlying File in UnsignedBinary.
-// The caller can use this file for further operations (e.g., reading,
-// copying, or renaming).
+// RemoveSignature uses the Windows SDK signtool.exe to remove a digital signature
+// from the given binary. It returns an UnsignedBinary if the operation succeeds,
+// or an error if it fails.
+//
+//   - binary: The file from which the signature should be removed.
+//   - returns: An UnsignedBinary containing the same file with the signature removed,
+//     or an error if removal fails (e.g., if the file isn't signed or can't be accessed).
 func RemoveSignature(binary base.File) (UnsignedBinary, error) {
 	winSdk, err := FindWinSdk()
 	if err != nil {

pkg/win/win_sdk.go

@@ -32,18 +32,27 @@ const supportedArch = "x64"
 
 var availableSdk *WinSdk
 
+// WinSdk encapsulates a Windows SDK installation by holding a reference
+// to its binaries directory.
 type WinSdk struct {
 	binDir base.Directory
 }
 
+// Path returns the absolute path to the Windows SDK bin directory.
 func (sdk *WinSdk) Path() base.AbsPath {
 	return sdk.binDir.AbsPath()
 }
 
+// SigntoolPath returns the absolute path to the signtool.exe located within
+// the Windows SDK bin directory.
 func (sdk *WinSdk) SigntoolPath() base.AbsPath {
 	return sdk.Path().Join(base.RelPathFromEntries("signtool.exe"))
 }
 
+// FindWinSdk attempts to locate a Windows SDK installation by first checking
+// the system PATH for signtool.exe and, if not found, falling back to the
+// default Windows Kits installation location.
+// It returns a WinSdk instance if found, or an error if no suitable SDK can be located.
 func FindWinSdk() (*WinSdk, error) {
 	if availableSdk != nil {
 		return availableSdk, nil
@@ -63,6 +72,8 @@ func FindWinSdk() (*WinSdk, error) {
 	return defaultWinSdk, err
 }
 
+// WinSdkFromPathEnv tries to locate signtool.exe by invoking the "where" command.
+// If found, it converts the result to a base.Directory and returns a WinSdk instance.
 func WinSdkFromPathEnv() (*WinSdk, error) {
 	where, err := base.ExecCommandAndGetOutput("where", []string{"signtool"})
 	if err != nil {
@@ -75,6 +86,9 @@ func WinSdkFromPathEnv() (*WinSdk, error) {
 	return &WinSdk{sdkBinDir}, err
 }
 
+// DefaultWinSdk searches the default Windows SDK install path for a Windows 10/11 SDK.
+// It looks for a directory structure matching "bin/10/<version>/<supportedArch>" and returns
+// the latest valid WinSdk found. If none is found, an error with installation instructions is returned.
 func DefaultWinSdk() (*WinSdk, error) {
 	defaultWinSdksInstallDir, err := base.DirectoryFromPathString(defaultWinSdksInstallPath)
 	if err != nil {
@@ -87,7 +101,6 @@ func DefaultWinSdk() (*WinSdk, error) {
 		versions := sdkVersionsDir.ChildDirs()
 		sort.SliceStable(versions, func(i, j int) bool { return versions[i].AbsPath().Base() > versions[j].AbsPath().Base() })
 		for _, version := range versions {
-			fmt.Println(version.AbsPath().String())
 			if sdkBinPath, err := version.AbsPath().Join(base.RelPathFromEntries(supportedArch)).AsDirectory(); err == nil {
 				return &WinSdk{sdkBinPath}, nil
 			} else {