macOS split tunneling support iOS/ iPad apps (#9093)

* Add support to show iPad and iPhone apps in split-tunnling on macOS.

* Split-tunnling UI changes

* code review updates

* FIx ios binding issue

* code review updates (#9098)

* code review updates

---------

Co-authored-by: atavism <paul@getlantern.org>
Co-authored-by: atavism <atavism@users.noreply.github.com>

Author: jigar-f

lantern-core/apps/apps.go

@@ -158,6 +158,12 @@ func scanAppDirs(appDirs []string, seen map[string]bool, excludeDirs []string, c
 			keyName := normalizeKey(rawName)
 
 			if seen[keyID] || seen[keyPath] || (runtime.GOOS != "windows" && seen[keyName]) {
+				// Don't descend into a bundle we already know about, or its
+				// embedded helper apps (Xcode's agents, inspectors, ...) get
+				// listed as if they were installed apps.
+				if appIsDir {
+					return filepath.SkipDir
+				}
 				return nil
 			}
 
@@ -176,6 +182,8 @@ func scanAppDirs(appDirs []string, seen map[string]bool, excludeDirs []string, c
 				AppPath:   path,
 				IconPath:  iconPath,
 				IconBytes: iconBytes,
+
+				WrappedBundle: wrappedBundleName(path),
 			}
 
 			if cb != nil {

lantern-core/apps/apps_darwin.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"howett.net/plist"
 )
@@ -36,8 +37,34 @@ func loadInstalledAppsPlatform(appDirs []string, seen map[string]bool, excludeDi
 	return scanAppDirs(appDirs, seen, excludeDirs, cb)
 }
 
+// bundleInfoPlist returns the bundle's Info.plist path and, for iPhone/iPad
+// apps (<App>.app/Wrapper/<Inner>.app, no Contents/), the inner bundle name.
+func bundleInfoPlist(appPath string) (plistPath, wrappedBundle string) {
+	native := filepath.Join(appPath, "Contents", "Info.plist")
+	if _, err := os.Stat(native); err == nil {
+		return native, ""
+	}
+	// Not Glob: appPath may contain pattern characters such as "[".
+	entries, _ := os.ReadDir(filepath.Join(appPath, "Wrapper"))
+	for _, e := range entries {
+		if !e.IsDir() || !strings.HasSuffix(e.Name(), ".app") {
+			continue
+		}
+		plist := filepath.Join(appPath, "Wrapper", e.Name(), "Info.plist")
+		if _, err := os.Stat(plist); err == nil {
+			return plist, e.Name()
+		}
+	}
+	return native, ""
+}
+
+func wrappedBundleName(appPath string) string {
+	_, wrapped := bundleInfoPlist(appPath)
+	return wrapped
+}
+
 func getAppID(appPath string) (string, error) {
-	plistPath := filepath.Join(appPath, "Contents", "Info.plist")
+	plistPath, _ := bundleInfoPlist(appPath)
 	file, err := os.Open(plistPath)
 	if err != nil {
 		return "", fmt.Errorf("unable to open plist: %w", err)

lantern-core/apps/apps_data.go

@@ -6,5 +6,8 @@ type AppData struct {
 	AppPath   string `json:"appPath"`
 	IconPath  string `json:"iconPath"`
 	IsBrowser bool   `json:"isBrowser"`
-	IconBytes []byte `json:"iconBytes,omitempty"`
+	// WrappedBundle is the inner bundle name (<App>.app/Wrapper/<this>) for
+	// iPhone and iPad apps on macOS; empty for native bundles.
+	WrappedBundle string `json:"wrappedBundle,omitempty"`
+	IconBytes     []byte `json:"iconBytes,omitempty"`
 }

lantern-core/apps/apps_exclude_darwin.go

@@ -4,7 +4,6 @@ package apps
 
 import (
 	"os"
-	"path/filepath"
 	"strings"
 
 	"howett.net/plist"
@@ -24,7 +23,7 @@ func shouldExcludeAppBundle(appPath, rawName, bundleID string) bool {
 		return true
 	}
 
-	plistPath := filepath.Join(appPath, "Contents", "Info.plist")
+	plistPath, _ := bundleInfoPlist(appPath)
 	f, err := os.Open(plistPath)
 	if err != nil {
 		return false

lantern-core/apps/apps_other.go

@@ -19,3 +19,6 @@ func getAppID(appPath string) (string, error) { return appPath, nil }
 func loadInstalledAppsPlatform(appDirs []string, seen map[string]bool, excludeDirs []string, cb Callback) []*AppData {
 	return nil
 }
+
+// Only macOS has iPhone/iPad wrapper bundles.
+func wrappedBundleName(string) string { return "" }

lantern-core/apps/apps_test.go

@@ -3,6 +3,10 @@
 package apps
 
 import (
+	"bytes"
+	"image"
+	"image/png"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -12,6 +16,26 @@ import (
 	"github.com/alecthomas/assert/v2"
 )
 
+// pngBytes encodes a square PNG of the given side. A noisy image compresses
+// poorly, so a small noisy icon can be more bytes than a large flat one.
+func pngBytes(t *testing.T, side int, noisy bool) string {
+	t.Helper()
+	img := image.NewNRGBA(image.Rect(0, 0, side, side))
+	rng := rand.New(rand.NewSource(int64(side)))
+	for i := range img.Pix {
+		if noisy {
+			img.Pix[i] = byte(rng.Intn(256))
+		} else {
+			img.Pix[i] = 0xff
+		}
+	}
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, img); err != nil {
+		t.Fatal(err)
+	}
+	return buf.String()
+}
+
 func writeFile(t *testing.T, path, content string, mode os.FileMode) {
 	t.Helper()
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
@@ -200,3 +224,100 @@ func TestLoadInstalledAppsWithDirs_EmitsCachedThenNew(t *testing.T) {
 		t.Fatalf("callback did not receive both cached and fresh apps; got %v", seen)
 	}
 }
+
+// makeWrappedAppBundle mimics an iPhone/iPad app installed from the Mac App
+// Store: no Contents/, the real bundle under Wrapper/ with a different name,
+// Info.plist at its root and PNG icons instead of .icns.
+func makeWrappedAppBundle(t *testing.T, root, name, inner, bundleID string) string {
+	t.Helper()
+	app := filepath.Join(root, name+".app")
+	innerApp := filepath.Join(app, "Wrapper", inner+".app")
+	infoPlist := `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleIdentifier</key>
+	<string>` + bundleID + `</string>
+</dict>
+</plist>`
+	writeFile(t, filepath.Join(innerApp, "Info.plist"), infoPlist, 0o644)
+	writeFile(t, filepath.Join(innerApp, "AppIcon29x29.png"), pngBytes(t, 29, false), 0o644)
+	writeFile(t, filepath.Join(innerApp, "AppIcon60x60@3x.png"), pngBytes(t, 180, false), 0o644)
+	if err := os.Symlink(filepath.Join("Wrapper", inner+".app"), filepath.Join(app, "WrappedBundle")); err != nil {
+		t.Fatal(err)
+	}
+	return app
+}
+
+func TestScanAppDirs_FindsWrappedIOSApp(t *testing.T) {
+	if runtime.GOOS != "darwin" {
+		t.Skip("test requires macOS .app bundle scanning")
+	}
+	tmp := t.TempDir()
+	root := filepath.Join(tmp, "Applications")
+	if err := os.MkdirAll(root, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	appPath := makeWrappedAppBundle(t, root, "Stream", "NetworkSniffer", "com.fish.stream")
+	nativePath := makeAppBundle(t, root, "Native", "com.example.native", false)
+	// Brackets are glob metacharacters; the bundle must still be found.
+	makeWrappedAppBundle(t, root, "Stream [Beta]", "NetworkSnifferBeta", "com.fish.stream.beta")
+
+	apps := scanAppDirs([]string{root}, map[string]bool{}, excludeDirs, nil)
+	if len(apps) != 3 {
+		t.Fatalf("expected 3 apps (outer wrappers only, inner bundles must not be listed separately), got %d: %+v", len(apps), apps)
+	}
+	byID := map[string]*AppData{}
+	for _, a := range apps {
+		byID[a.BundleID] = a
+	}
+
+	wrapped := byID["com.fish.stream"]
+	if wrapped == nil {
+		t.Fatalf("wrapped app missing: %+v", apps)
+	}
+	if wrapped.AppPath != appPath {
+		t.Errorf("app path: got %s want %s", wrapped.AppPath, appPath)
+	}
+	if wrapped.Name != "Stream" {
+		t.Errorf("name should come from the outer bundle: %s", wrapped.Name)
+	}
+	if wrapped.WrappedBundle != "NetworkSniffer.app" {
+		t.Errorf("wrappedBundle: got %q want NetworkSniffer.app", wrapped.WrappedBundle)
+	}
+	if filepath.Base(wrapped.IconPath) != "AppIcon60x60@3x.png" {
+		t.Errorf("icon should be the largest PNG: %s", wrapped.IconPath)
+	}
+
+	if beta := byID["com.fish.stream.beta"]; beta == nil || beta.WrappedBundle != "NetworkSnifferBeta.app" {
+		t.Errorf("bracketed wrapped app missing or wrong inner bundle: %+v", beta)
+	}
+
+	native := byID["com.example.native"]
+	if native == nil || native.AppPath != nativePath {
+		t.Fatalf("native app missing or wrong path: %+v", native)
+	}
+	if native.WrappedBundle != "" {
+		t.Errorf("native app must not report a wrapped bundle: %q", native.WrappedBundle)
+	}
+}
+
+func TestScanAppDirs_SeenBundleIsNotDescendedInto(t *testing.T) {
+	if runtime.GOOS != "darwin" {
+		t.Skip("test requires macOS .app bundle scanning")
+	}
+	root := filepath.Join(t.TempDir(), "Applications")
+	if err := os.MkdirAll(root, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	outer := makeAppBundle(t, root, "Xcode", "com.apple.dt.Xcode", false)
+	// Helper app embedded in the outer bundle, as Xcode ships.
+	makeAppBundle(t, filepath.Join(outer, "Contents", "Applications"), "Instruments", "com.apple.dt.Instruments", false)
+
+	// Outer bundle already known from the cache.
+	seen := map[string]bool{normalizeKey(outer): true}
+	apps := scanAppDirs([]string{root}, seen, excludeDirs, nil)
+	if len(apps) != 0 {
+		t.Fatalf("expected no apps (outer already seen, helper must not surface), got %+v", apps)
+	}
+}

lantern-core/apps/apps_windows.go

@@ -1913,3 +1913,6 @@ func dirExists(p string) bool {
 func getAppID(appPath string) (string, error) {
 	return appPath, nil
 }
+
+// Only macOS has iPhone/iPad wrapper bundles.
+func wrappedBundleName(string) string { return "" }

lantern-core/apps/icons_darwin.go

@@ -1,30 +1,74 @@
-//go:build darwin
+//go:build darwin && !ios
 
 package apps
 
 import (
 	"bytes"
 	"fmt"
-	"log/slog"
+	"image"
+	_ "image/png"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
+	"strings"
 )
 
 // getIconPath finds the .icns file inside the app bundle
 func getIconPath(appPath string) (string, error) {
 	resourcesPath := filepath.Join(appPath, "Contents", "Resources")
-	matches, err := filepath.Glob(filepath.Join(resourcesPath, "*.icns"))
+	entries, err := os.ReadDir(resourcesPath)
+	if err != nil && !os.IsNotExist(err) {
+		return "", fmt.Errorf("read icon directory: %w", err)
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".icns") {
+			return filepath.Join(resourcesPath, entry.Name()), nil
+		}
+	}
+	return wrappedIconPath(appPath), nil
+}
+
+// wrappedIconPath picks the AppIcon*.png with the most pixels from an
+// iPhone/iPad bundle's inner .app. Those bundles carry no .icns; sips resizes
+// PNG just as well. Ranking is by raster size, not byte size: a detailed
+// small icon can encode to more bytes than a flat large one.
+func wrappedIconPath(appPath string) string {
+	plistPath, wrapped := bundleInfoPlist(appPath)
+	if wrapped == "" {
+		return ""
+	}
+	iconDir := filepath.Dir(plistPath)
+	entries, err := os.ReadDir(iconDir)
 	if err != nil {
-		wrapped := fmt.Errorf("error globbing icons for %s: %w", appPath, err)
-		slog.Error("glob error:", "error", wrapped)
-		return "", wrapped
+		return ""
+	}
+	best, bestPixels := "", -1
+	for _, entry := range entries {
+		if entry.IsDir() || !strings.HasPrefix(entry.Name(), "AppIcon") || !strings.HasSuffix(entry.Name(), ".png") {
+			continue
+		}
+		iconPath := filepath.Join(iconDir, entry.Name())
+		if pixels := pngPixels(iconPath); pixels > bestPixels {
+			best, bestPixels = iconPath, pixels
+		}
 	}
-	if len(matches) == 0 {
-		return "", nil
+	return best
+}
+
+// pngPixels returns width*height from the PNG header, or -1 if the file is
+// not a decodable PNG. Only the header is read.
+func pngPixels(path string) int {
+	f, err := os.Open(path)
+	if err != nil {
+		return -1
+	}
+	defer f.Close()
+	cfg, _, err := image.DecodeConfig(f)
+	if err != nil {
+		return -1
 	}
-	return matches[0], nil
+	return cfg.Width * cfg.Height
 }
 
 func getIconBytes(appPath string) ([]byte, error) {

lantern-core/apps/icons_darwin_test.go

@@ -0,0 +1,56 @@
+//go:build darwin && !ios
+
+package apps
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGetIconPath_LiteralBundlePaths(t *testing.T) {
+	for _, name := range []string{"App [Beta]", "App ["} {
+		t.Run(name, func(t *testing.T) {
+			root := t.TempDir()
+			native := makeAppBundle(t, root, name, "test.native", true)
+			wrapped := makeWrappedAppBundle(t, root, name+" Wrapped", "Inner [Beta]", "test.wrapped")
+			for app, want := range map[string]string{
+				native:  filepath.Join(native, "Contents", "Resources", "AppIcon.icns"),
+				wrapped: filepath.Join(wrapped, "Wrapper", "Inner [Beta].app", "AppIcon60x60@3x.png"),
+			} {
+				got, err := getIconPath(app)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got != want {
+					t.Errorf("getIconPath(%q) = %q, want %q", app, got, want)
+				}
+			}
+		})
+	}
+}
+
+func TestWrappedIconPath_RanksByPixelsNotBytes(t *testing.T) {
+	root := t.TempDir()
+	app := makeWrappedAppBundle(t, root, "Ranked", "Inner", "test.ranked")
+	inner := filepath.Join(app, "Wrapper", "Inner.app")
+	for _, e := range []struct{ name, data string }{
+		{"AppIcon40x40.png", pngBytes(t, 40, true)},   // few pixels, many bytes
+		{"AppIcon1024.png", pngBytes(t, 1024, false)}, // many pixels, few bytes
+		{"AppIcon-bad.png", "not a png"},
+	} {
+		writeFile(t, filepath.Join(inner, e.name), e.data, 0o644)
+	}
+	if err := os.Remove(filepath.Join(inner, "AppIcon60x60@3x.png")); err != nil {
+		t.Fatal(err)
+	}
+	small, _ := os.Stat(filepath.Join(inner, "AppIcon40x40.png"))
+	large, _ := os.Stat(filepath.Join(inner, "AppIcon1024.png"))
+	if small.Size() <= large.Size() {
+		t.Fatalf("fixture invalid: noisy 40px icon (%d B) should exceed flat 1024px icon (%d B)", small.Size(), large.Size())
+	}
+	want := filepath.Join(inner, "AppIcon1024.png")
+	if got := wrappedIconPath(app); got != want {
+		t.Errorf("wrappedIconPath = %q, want %q", got, want)
+	}
+}