Added README.md

.gitignore

@@ -5,3 +5,4 @@
 /APKINDEX
 /APPINDEX
 /browser-amd64-nightly-linux.tar.gz
+/browser-amd64-nightly-windows.tar.gz

README.md

@@ -0,0 +1,145 @@
+<p align="center">
+  <img src="https://weforge.xyz/Spitfire/Branding/raw/branch/main/active/browser/icon.svg" alt="Logo" width="64" height="64">
+</p>
+
+<p align="center" style="font-size: 32px;">
+  <strong>Spitfire Builder</strong>
+</p>
+
+<p align="center">
+This is a "simple" script for building the Spitfire Browser based on Mozilla Firefox source code.
+</p>
+
+## Dependencies
+
+- Mercurial (hg)
+- Git
+- Golang (tested with v1.21)
+- Python 3.11 and pip3
+
+# Example usage:
+
+## Build:
+
+```sh
+go run . -a
+```
+
+## Upload:
+
+```sh
+go run . --upload -c --upload-path=./mozilla-central/obj-x86_64-pc-linux-gnu/dist/bin
+```
+
+## Build and upload:
+
+```sh
+go run . --upload -c --upload-path=./mozilla-central/obj-x86_64-pc-linux-gnu/dist/bin -a
+```
+
+## Display all flags:
+
+```sh
+go run . -h
+```
+
+### Config file for uploading example:
+
+*sourceforge_config.json*
+
+```json
+{
+    "SFKeyPath": "~/.ssh/id_rsa.pub",
+    "SFUser": "internet-addict",
+    "SFHost": "web.sourceforge.net",
+    "SFProject": "spitfire-browser"
+}
+```
+
+## APPINDEX example:
+
+```
+C:905cd0cc2dea9e400e1ecd099462b6b19188a9f1
+P:Spitfire
+R:nightly
+V:2024.09.08
+A:amd64
+S:788506622
+I:3324483350
+T:Spitfire build
+U:https://spitfirebrowser.com/
+L:AGPL-3.0
+o:browser
+m:Internet Addict
+t:1725830641
+c:905cd0cc2dea9e400e1ecd099462b6b19188a9f1
+D:
+p:linux
+q:
+Z:905cd0cc2dea9e400e1ecd099462b6b19188a9f1
+```
+
+## Repositary structure
+
+```
+spitfire-browser/
+├── browser/
+│   ├── amd64/
+│   │   ├── stable/
+│   │   │   ├── latest/deb.tar.gz
+│   │   │   ├── x.x.x/deb.tar.gz
+│   │   ├── nightly/
+│   │       ├── latest/deb.tar.gz
+│   │       ├── yyyy-mm-dd/deb.tar.gz
+│   ├── arm/
+│   │   ├── stable/
+│   │   │   ├── latest/
+│   │   │   ├── x.x.x/
+│   │   ├── nightly/
+│   │       ├── latest/
+│   │       ├── yyyy-mm-dd/
+├── cli-package-manager/
+│   ├── stable/
+│   │   ├── latest/
+│   │   ├── x.x.x/
+│   ├── nightly/
+│       ├── latest/
+│       ├── yyyy-mm-dd/
+├── gui-installer/
+│   ├── stable/
+│   │   ├── latest/
+│   │   ├── x.x.x/
+│   ├── nightly/
+│       ├── latest/
+│       ├── yyyy-mm-dd/
+├── gui-package-manager/
+│   ├── stable/
+│   │   ├── latest/
+│   │   ├── x.x.x/
+│   ├── nightly/
+│       ├── latest/
+│       ├── yyyy-mm-dd/
+├── addons/
+│   ├── themes/
+│   │   ├── stable/
+│   │   │   ├── latest/
+│   │   │   ├── x.x.x/
+│   │   ├── nightly/
+│   │       ├── latest/
+│   │       ├── yyyy-mm-dd/
+│   ├── custom-configs/
+│   │   ├── stable/
+│   │   │   ├── latest/
+│   │   │   ├── x.x.x/
+│   │   ├── nightly/
+│   │       ├── latest/
+│   │       ├── yyyy-mm-dd/
+│   ├── search-engines/
+│       ├── stable/
+│       │   ├── latest/
+│       │   ├── x.x.x/
+│       ├── nightly/
+│           ├── latest/
+│           ├── yyyy-mm-dd/
+├── APPINDEX
+```

main.go

@@ -7,8 +7,8 @@ import (
 	"os"
 	"path/filepath"
 	"runtime" // for detecting system architecture and platform
-    "time"
 	"spitfire/spitfire"
+	"time"
 	//"errors"
 )
 
@@ -60,13 +60,19 @@ func init() {
 }
 
 func printHelp() {
-    fmt.Println("Usage: ./main -p=<path-to-build> -t=<target> [-c|--compress] [-v|--version=<version>] [-component=<component>] [-arch=<architecture>] [-release=<release>] [-platform=<platform>]")
+	fmt.Println("Usage: go run . -p=<path-to-build> -t=<target> [-c|--compress] [-v|--version=<version>] [-component=<component>] [-arch=<architecture>] [-release=<release>] [-platform=<platform>]")
 	flag.PrintDefaults()
 	fmt.Println("Example: go run . --upload -c --upload-path=./mozilla-central/obj-x86_64-pc-linux-gnu/dist/bin -a")
 	os.Exit(0)
 }
 
 func main() {
+	// // Check system dependencies
+	// err := spitfire.CheckSystemDependencies()
+	// if err != nil {
+	// 	log.Fatalf("System check failed: %v", err)
+	// }
+
 	flag.Parse()
 
 	if flag.Lookup("h").Value.(flag.Getter).Get().(bool) {
@@ -79,13 +85,30 @@ func main() {
 	}
 
 	// Save the initial directory
-    var err error
+	var err2 error
-    initialDir, err = os.Getwd()
+	initialDir, err2 = os.Getwd()
-    if err != nil {
+	if err2 != nil {
-        log.Fatalf("Failed to get current working directory: %v", err)
+		log.Fatalf("Failed to get current working directory: %v", err2)
 	}
 	fmt.Printf("Initial working directory: %s\n", initialDir)
 
+	// Convert buildPath and uploadPath to absolute paths
+	if buildPath != "" {
+		buildPath, err2 = spitfire.ResolvePath(buildPath)
+		if err2 != nil {
+			log.Fatalf("Failed to convert buildPath to absolute path: %v", err2)
+		}
+		fmt.Printf("Resolved buildPath: %s\n", buildPath)
+	}
+
+	if uploadPath != "" {
+		uploadPath, err2 = spitfire.ResolvePath(uploadPath)
+		if err2 != nil {
+			log.Fatalf("Failed to convert uploadPath to absolute path: %v", err2)
+		}
+		fmt.Printf("Resolved uploadPath: %s\n", uploadPath)
+	}
+
 	if all || buildFlag {
 		BuildProcess()
 	}

sourceforge_config.json

@@ -4,4 +4,3 @@
   "SFHost": "web.sourceforge.net",
   "SFProject": "spitfire-browser"
 }
-  

spitfire/build.go

@@ -5,13 +5,39 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 )
 
 // Array to store errors
 var errors []string
 
+// SetGlobalEnv sets the MOZILLABUILD environment variable globally for the user (or system)
+func SetGlobalEnv(variable, value string, scope string) error {
+	if runtime.GOOS == "windows" {
+		var cmd *exec.Cmd
+		if scope == "user" {
+			cmd = exec.Command("setx", variable, value) // Set for current user
+		} else if scope == "system" {
+			cmd = exec.Command("setx", variable, value, "/M") // Set for system (requires admin privileges)
+		} else {
+			return fmt.Errorf("unknown scope: %s", scope)
+		}
+
+		// Run the command
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			return fmt.Errorf("failed to set environment variable %s=%s: %v\nOutput: %s", variable, value, err, string(out))
+		}
+		fmt.Printf("Successfully set %s=%s\n", variable, value)
+		return nil
+	} else {
+		return fmt.Errorf("global environment variable setting is not supported on non-Windows systems")
+	}
+}
+
 // Run an external command like scp or rsync
 func runCommand(command string, args ...string) error {
+	fmt.Printf("Running command: %s %v\n", command, args)
 	cmd := exec.Command(command, args...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -20,9 +46,13 @@ func runCommand(command string, args ...string) error {
 
 // Function to resolve paths using absolute path
 func ResolvePath(path string) (string, error) {
+	// Convert Unix-style slashes to the platform's native slashes
+	path = filepath.FromSlash(path)
+
+	// Get the absolute path
 	absPath, err := filepath.Abs(path)
 	if err != nil {
-		return "", fmt.Errorf("failed to resolve path: %s", path)
+		return "", fmt.Errorf("failed to resolve path: %s, error: %v", path, err)
 	}
 	return absPath, nil
 }
@@ -54,10 +84,21 @@ func CleanBuild(sourcePath string) {
 		errors = append(errors, "Failed to navigate to source directory.")
 		return
 	}
+
+	// Use the appropriate mach command for Windows or Unix-like systems
+	var machCmd string
+	if runtime.GOOS == "windows" {
+		machCmd = ".\\mach"
+	} else {
+		machCmd = "./mach"
+	}
+
+	// Revert uncommitted changes
 	if err := runCommand("hg", "revert", "--all", "--no-backup"); err != nil {
 		errors = append(errors, "Failed to revert changes in Mozilla repository.")
 	}
-	if err := runCommand("./mach", "clobber"); err != nil {
+	// Clean the build
+	if err := runCommand(machCmd, "clobber"); err != nil {
 		errors = append(errors, "Failed to clean build.")
 	}
 }
@@ -113,9 +154,19 @@ func UpdatePatches(patchesDir, patchesRepo, sourcePath string) {
 			errors = append(errors, "Failed to clone patches repository.")
 		}
 	}
+
+	// Handle platform-specific rsync command
 	fmt.Println("Copying files from patches directory to Firefox source directory...")
+	if runtime.GOOS == "windows" {
+		// Use robocopy for Windows
+		if err := runCommand("robocopy", patchesDir, sourcePath, "*", "/S", "/XF", ".git", "/XD", ".git"); err != nil {
+			errors = append(errors, "Failed to copy files (Windows robocopy).")
+		}
+	} else {
+		// Use rsync for Unix-like systems
 		if err := runCommand("rsync", "-av", "--exclude=.git", patchesDir+"/", sourcePath+"/"); err != nil {
-		errors = append(errors, "Failed to copy files.")
+			errors = append(errors, "Failed to copy files (rsync).")
+		}
 	}
 }
 
@@ -126,7 +177,16 @@ func Configure(sourcePath string) {
 		errors = append(errors, "Failed to navigate to source directory.")
 		return
 	}
-	if err := runCommand("./mach", "configure"); err != nil {
+
+	// Use the appropriate mach command for Windows or Unix-like systems
+	var machCmd string
+	if runtime.GOOS == "windows" {
+		machCmd = ".\\mach"
+	} else {
+		machCmd = "./mach"
+	}
+
+	if err := runCommand(machCmd, "configure"); err != nil {
 		errors = append(errors, "Configuration failed.")
 	}
 }
@@ -138,7 +198,16 @@ func Build(sourcePath string) {
 		errors = append(errors, "Failed to navigate to source directory.")
 		return
 	}
-	if err := runCommand("./mach", "build"); err != nil {
+
+	// Use the appropriate mach command for Windows or Unix-like systems
+	var machCmd string
+	if runtime.GOOS == "windows" {
+		machCmd = ".\\mach"
+	} else {
+		machCmd = "./mach"
+	}
+
+	if err := runCommand(machCmd, "build"); err != nil {
 		errors = append(errors, "Build failed.")
 	}
 }
@@ -146,11 +215,16 @@ func Build(sourcePath string) {
 // Function to run the project after build
 func RunProject(sourcePath string) {
 	fmt.Println("Running the project...")
-	if err := os.Chdir(sourcePath); err != nil {
+
-		errors = append(errors, "Failed to navigate to source directory.")
+	// Use the appropriate mach command for Windows or Unix-like systems
-		return
+	var machCmd string
+	if runtime.GOOS == "windows" {
+		machCmd = ".\\mach"
+	} else {
+		machCmd = "./mach"
 	}
-	if err := runCommand("./mach", "run"); err != nil {
+
+	if err := runCommand(machCmd, "run"); err != nil {
 		errors = append(errors, "Failed to run the project.")
 	}
 }

spitfire/checks.go

@@ -0,0 +1,78 @@
+package spitfire
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+// CheckSystemDependencies ensures that required tools for building are installed.
+func CheckSystemDependencies() error {
+	requiredTools := map[string]string{
+		"git":     "https://git-scm.com/download/win",     // Git
+		"python":  "https://www.python.org/downloads/",    // Python
+		"pip3":    "https://pip.pypa.io/en/stable/installing/", // Pip3
+	}
+
+	if runtime.GOOS == "windows" {
+		// Check for MozillaBuild installation
+		mozBuildPath := os.Getenv("MOZILLABUILD")
+		if mozBuildPath == "" {
+			mozBuildPath = "C:\\mozilla-build" // Default to standard MozillaBuild path
+		}
+
+		// Check if MozillaBuild exists at the specified location
+		if !dirExists(mozBuildPath) {
+			requiredTools["mozbuild"] = "https://ftp.mozilla.org/pub/mozilla/libraries/win32/MozillaBuildSetup-Latest.exe"
+		}
+	}
+
+	missingTools := []string{}
+
+	// Check for each required tool
+	for tool, downloadLink := range requiredTools {
+		if !isCommandAvailable(tool) {
+			missingTools = append(missingTools, fmt.Sprintf("%s (Download: %s)", tool, downloadLink))
+		}
+	}
+
+	// Special check for mach in the local source directory (mozilla-central)
+	machPath := filepath.Join("mozilla-central", "mach")
+	if !fileExists(machPath) {
+		missingTools = append(missingTools, fmt.Sprintf("mach (run from mozilla-central directory)"))
+	}
+
+	if len(missingTools) > 0 {
+		fmt.Println("The following tools are missing and are required for the build:")
+		for _, tool := range missingTools {
+			fmt.Println(" - " + tool)
+		}
+		return fmt.Errorf("missing required tools")
+	}
+
+	fmt.Println("All required system dependencies are installed.")
+	return nil
+}
+
+// isCommandAvailable checks if a command/tool is available on the system.
+func isCommandAvailable(command string) bool {
+	_, err := exec.LookPath(command)
+	return err == nil
+}
+
+// fileExists checks if a file exists at the given path.
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// dirExists checks if a directory exists at the given path.
+func dirExists(path string) bool {
+	info, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return info.IsDir()
+}