Merge branch 'main' into dev

install.ps1

@@ -40,6 +40,7 @@ if ($GitHubProxy -ne '') { $ProxyDisplay = $GitHubProxy } else { $ProxyDisplay =
 switch ($env:PROCESSOR_ARCHITECTURE) {
     'AMD64' { $arch = 'amd64' }
     'ARM64' { $arch = 'arm64' }
+    'x86' { $arch = '386' }
     Default { Log-Error "Unsupported architecture: $env:PROCESSOR_ARCHITECTURE"; exit 1 }
 }
 

install.sh

@@ -57,6 +57,13 @@ case $os_type in
     Linux)
         os_name="linux"
         ;;
+    FreeBSD)
+        os_name="freebsd"
+        ;;
+    MINGW*|MSYS*|CYGWIN*)
+        os_name="windows"
+        target_dir="/c/komari"  # Use C:\komari on Windows
+        ;;
     *)
         log_error "Unsupported operating system: $os_type"
         exit 1
@@ -295,23 +302,45 @@ install_dependencies
 # Install vnstat if needed for month-rotate
 install_vnstat
 
+# Architecture detection with platform-specific support
 arch=$(uname -m)
 case $arch in
     x86_64)
         arch="amd64"
         ;;
-    aarch64)
+    aarch64|arm64)
         arch="arm64"
         ;;
-    arm64)
-        arch="arm64"
+    i386|i686)
+        # x86 (32-bit) support
+        case $os_name in
+            freebsd|linux|windows)
+                arch="386"
+                ;;
+            *)
+                log_error "32-bit x86 architecture not supported on $os_name"
+                exit 1
+                ;;
+        esac
+        ;;
+    armv7*|armv6*)
+        # ARM 32-bit support
+        case $os_name in
+            freebsd|linux)
+                arch="arm"
+                ;;
+            *)
+                log_error "32-bit ARM architecture not supported on $os_name"
+                exit 1
+                ;;
+        esac
         ;;
     *)
-        log_error "Unsupported architecture: $arch"
+        log_error "Unsupported architecture: $arch on $os_name"
         exit 1
         ;;
 esac
-log_info "Detected architecture: ${GREEN}$arch${NC}"
+log_info "Detected OS: ${GREEN}$os_name${NC}, Architecture: ${GREEN}$arch${NC}"
 
 version_to_install="latest"
 if [ -n "$install_version" ]; then

monitoring/unit/mem.go

@@ -24,7 +24,7 @@ func Ram() RamInfo {
 		return raminfo
 	}
 	raminfo.Total = v.Total
-	raminfo.Used = v.Used
+	raminfo.Used = v.Total - v.Available
 
 	return raminfo
 }

monitoring/unit/os_linux.go

@@ -11,10 +11,17 @@ import (
 )
 
 func OSName() string {
+	// Check if it's an Android system
+	if androidVersion := detectAndroid(); androidVersion != "" {
+		return androidVersion
+	}
+
+	// Check if it's a Proxmox VE
 	if pveVersion := detectProxmoxVE(); pveVersion != "" {
 		return pveVersion
 	}
 
+	// Check if it's a Synology
 	if synologyName := detectSynology(); synologyName != "" {
 		return synologyName
 	}
@@ -157,6 +164,116 @@ func detectProxmoxVE() string {
 	return "Proxmox VE"
 }
 
+// detectAndroid detects if the system is Android and returns detailed information
+func detectAndroid() string {
+	// 1. Try to get Android version info using the getprop command
+	cmdGetprop := exec.Command("getprop", "ro.build.version.release")
+	version, err := cmdGetprop.Output()
+	if err == nil && len(version) > 0 {
+		versionStr := strings.TrimSpace(string(version))
+
+		// Get device model
+		cmdGetModel := exec.Command("getprop", "ro.product.model")
+		model, err2 := cmdGetModel.Output()
+		modelStr := strings.TrimSpace(string(model))
+
+		// Get manufacturer information
+		cmdGetBrand := exec.Command("getprop", "ro.product.brand")
+		brand, err3 := cmdGetBrand.Output()
+		brandStr := strings.TrimSpace(string(brand))
+
+		result := "Android " + versionStr
+
+		// Add brand and model information (if available)
+		if err2 == nil && modelStr != "" {
+			if err3 == nil && brandStr != "" && brandStr != modelStr {
+				result += " (" + brandStr + " " + modelStr + ")"
+			} else {
+				result += " (" + modelStr + ")"
+			}
+		}
+
+		return result
+	}
+
+	// 2. Try to check Android system build.prop file
+	if _, err := os.Stat("/system/build.prop"); err == nil {
+		return readAndroidBuildProp()
+	}
+
+	// 3. Check for typical Android directory structure
+	if isAndroidSystem() {
+		return "Android"
+	}
+
+	return ""
+}
+
+// readAndroidBuildProp reads Android version information from build.prop file
+func readAndroidBuildProp() string {
+	file, err := os.Open("/system/build.prop")
+	if err != nil {
+		return "Android"
+	}
+	defer file.Close()
+
+	var version, model, brand string
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		if strings.HasPrefix(line, "ro.build.version.release=") {
+			version = strings.TrimPrefix(line, "ro.build.version.release=")
+		} else if strings.HasPrefix(line, "ro.product.model=") {
+			model = strings.TrimPrefix(line, "ro.product.model=")
+		} else if strings.HasPrefix(line, "ro.product.brand=") {
+			brand = strings.TrimPrefix(line, "ro.product.brand=")
+		}
+
+		// If all information has been collected, we can exit early
+		if version != "" && model != "" && brand != "" {
+			break
+		}
+	}
+
+	if version != "" {
+		result := "Android " + version
+
+		if model != "" {
+			if brand != "" && brand != model {
+				result += " (" + brand + " " + model + ")"
+			} else {
+				result += " (" + model + ")"
+			}
+		}
+
+		return result
+	}
+
+	return "Android"
+}
+
+// isAndroidSystem determines if the system is Android by checking typical directory structure
+func isAndroidSystem() bool {
+	androidDirs := []string{
+		"/system/app",
+		"/system/priv-app",
+		"/data/app",
+		"/sdcard",
+	}
+
+	dirCount := 0
+	for _, dir := range androidDirs {
+		if info, err := os.Stat(dir); err == nil && info.IsDir() {
+			dirCount++
+		}
+	}
+
+	// Consider it an Android system only if at least 2 directories exist
+	return dirCount >= 2
+}
+
 // KernelVersion returns the kernel version on Linux systems
 func KernelVersion() string {
 	out, err := exec.Command("uname", "-r").Output()