app: add code for macOS and Windows apps under 'app' (#12933)

* app: add code for macOS and Windows apps under 'app' * app: add readme * app: windows and linux only for now * ci: fix ui CI validation --------- Co-authored-by: jmorganca <jmorganca@gmail.com>
2026-04-29 23:48:32 -05:00 · 2025-11-04 11:40:17 -08:00
parent a4770107a6
commit d3b4b9970a
212 changed files with 102976 additions and 1482 deletions
--- a/app/cmd/app/AppDelegate.h
+++ b/app/cmd/app/AppDelegate.h
@@ -0,0 +1,7 @@
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+
+@end
--- a/app/cmd/app/app.go
+++ b/app/cmd/app/app.go
@@ -0,0 +1,478 @@
+//go:build windows || darwin
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/ollama/ollama/app/auth"
+	"github.com/ollama/ollama/app/logrotate"
+	"github.com/ollama/ollama/app/server"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/tools"
+	"github.com/ollama/ollama/app/ui"
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var (
+	wv           = &Webview{}
+	uiServerPort int
+)
+
+var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
+
+var (
+	fastStartup = false
+	devMode     = false
+)
+
+type appMove int
+
+const (
+	CannotMove appMove = iota
+	UserDeclinedMove
+	MoveCompleted
+	AlreadyMoved
+	LoginSession
+	PermissionDenied
+	MoveError
+)
+
+func main() {
+	startHidden := false
+	var urlSchemeRequest string
+	if len(os.Args) > 1 {
+		for _, arg := range os.Args {
+			// Handle URL scheme requests (Windows)
+			if strings.HasPrefix(arg, "ollama://") {
+				urlSchemeRequest = arg
+				slog.Info("received URL scheme request", "url", arg)
+				continue
+			}
+			switch arg {
+			case "serve":
+				fmt.Fprintln(os.Stderr, "serve command not supported, use ollama")
+				os.Exit(1)
+			case "version", "-v", "--version":
+				fmt.Println(version.Version)
+				os.Exit(0)
+			case "background":
+				// When running the process in this "background" mode, we spawn a
+				// child process for the main app.  This is necessary so the
+				// "Allow in the Background" setting in MacOS can be unchecked
+				// without breaking the main app.  Two copies of the app are
+				// present in the bundle, one for the main app and one for the
+				// background initiator.
+				fmt.Fprintln(os.Stdout, "starting in background")
+				runInBackground()
+				os.Exit(0)
+			case "hidden", "-j", "--hide":
+				// startHidden suppresses the UI on startup, and can be triggered multiple ways
+				// On windows, path based via login startup detection
+				// On MacOS via [NSApp isHidden] from `open -j -a /Applications/Ollama.app` or equivalent
+				// On both via the "hidden" command line argument
+				startHidden = true
+			case "--fast-startup":
+				// Skip optional steps like pending updates to start quickly for immediate use
+				fastStartup = true
+			case "-dev", "--dev":
+				// Development mode: use local dev server and enable CORS
+				devMode = true
+			}
+		}
+	}
+
+	level := slog.LevelInfo
+	if debug {
+		level = slog.LevelDebug
+	}
+
+	logrotate.Rotate(appLogPath)
+	if _, err := os.Stat(filepath.Dir(appLogPath)); errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(filepath.Dir(appLogPath), 0o755); err != nil {
+			slog.Error(fmt.Sprintf("failed to create server log dir %v", err))
+			return
+		}
+	}
+
+	var logFile io.Writer
+	var err error
+	logFile, err = os.OpenFile(appLogPath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o755)
+	if err != nil {
+		slog.Error(fmt.Sprintf("failed to create server log %v", err))
+		return
+	}
+	// Detect if we're a GUI app on windows, and if not, send logs to console as well
+	if os.Stderr.Fd() != 0 {
+		// Console app detected
+		logFile = io.MultiWriter(os.Stderr, logFile)
+	}
+
+	handler := slog.NewTextHandler(logFile, &slog.HandlerOptions{
+		Level:     level,
+		AddSource: true,
+		ReplaceAttr: func(_ []string, attr slog.Attr) slog.Attr {
+			if attr.Key == slog.SourceKey {
+				source := attr.Value.Any().(*slog.Source)
+				source.File = filepath.Base(source.File)
+			}
+			return attr
+		},
+	})
+
+	slog.SetDefault(slog.New(handler))
+	logStartup()
+
+	// On Windows, check if another instance is running and send URL to it
+	// Do this after logging is set up so we can debug issues
+	if runtime.GOOS == "windows" && urlSchemeRequest != "" {
+		slog.Debug("checking for existing instance", "url", urlSchemeRequest)
+		if checkAndHandleExistingInstance(urlSchemeRequest) {
+			// The function will exit if it successfully sends to another instance
+			// If we reach here, we're the first/only instance
+		} else {
+			// No existing instance found, handle the URL scheme in this instance
+			go func() {
+				handleURLSchemeInCurrentInstance(urlSchemeRequest)
+			}()
+		}
+	}
+
+	if u := os.Getenv("OLLAMA_UPDATE_URL"); u != "" {
+		updater.UpdateCheckURLBase = u
+	}
+
+	// Detect if this is a first start after an upgrade, in
+	// which case we need to do some cleanup
+	var skipMove bool
+	if _, err := os.Stat(updater.UpgradeMarkerFile); err == nil {
+		slog.Debug("first start after upgrade")
+		err = updater.DoPostUpgradeCleanup()
+		if err != nil {
+			slog.Error("failed to cleanup prior version", "error", err)
+		}
+		// We never prompt to move the app after an upgrade
+		skipMove = true
+		// Start hidden after updates to prevent UI from opening automatically
+		startHidden = true
+	}
+
+	if !skipMove && !fastStartup {
+		if maybeMoveAndRestart() == MoveCompleted {
+			return
+		}
+	}
+
+	// Check if another instance is already running
+	// On Windows, focus the existing instance; on other platforms, kill it
+	handleExistingInstance(startHidden)
+
+	// on macOS, offer the user to create a symlink
+	// from /usr/local/bin/ollama to the app bundle
+	installSymlink()
+
+	var ln net.Listener
+	if devMode {
+		// Use a fixed port in dev mode for predictable API access
+		ln, err = net.Listen("tcp", "127.0.0.1:3001")
+	} else {
+		ln, err = net.Listen("tcp", "127.0.0.1:0")
+	}
+	if err != nil {
+		slog.Error("failed to find available port", "error", err)
+		return
+	}
+
+	port := ln.Addr().(*net.TCPAddr).Port
+	token := uuid.NewString()
+	wv.port = port
+	wv.token = token
+	uiServerPort = port
+
+	st := &store.Store{}
+
+	// Enable CORS in development mode
+	if devMode {
+		os.Setenv("OLLAMA_CORS", "1")
+
+		// Check if Vite dev server is running on port 5173
+		var conn net.Conn
+		var err error
+		for _, addr := range []string{"127.0.0.1:5173", "localhost:5173"} {
+			conn, err = net.DialTimeout("tcp", addr, 2*time.Second)
+			if err == nil {
+				conn.Close()
+				break
+			}
+		}
+
+		if err != nil {
+			slog.Error("Vite dev server not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Error: Vite dev server is not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Please run 'npm run dev' in the ui/app directory to start the UI in development mode")
+			os.Exit(1)
+		}
+	}
+
+	// Initialize tools registry
+	toolRegistry := tools.NewRegistry()
+	slog.Info("initialized tools registry", "tool_count", len(toolRegistry.List()))
+
+	// ctx is the app-level context that will be used to stop the app
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// octx is the ollama server context that will be used to stop the ollama server
+	octx, ocancel := context.WithCancel(ctx)
+
+	// TODO (jmorganca): instead we should instantiate the
+	// webview with the store instead of assigning it here, however
+	// making the webview a global variable is easier for now
+	wv.Store = st
+	done := make(chan error, 1)
+	osrv := server.New(st, devMode)
+	go func() {
+		slog.Info("starting ollama server")
+		done <- osrv.Run(octx)
+	}()
+
+	uiServer := ui.Server{
+		Token: token,
+		Restart: func() {
+			ocancel()
+			<-done
+			octx, ocancel = context.WithCancel(ctx)
+			go func() {
+				done <- osrv.Run(octx)
+			}()
+		},
+		Store:        st,
+		ToolRegistry: toolRegistry,
+		Dev:          devMode,
+		Logger:       slog.Default(),
+	}
+
+	srv := &http.Server{
+		Handler: uiServer.Handler(),
+	}
+
+	if _, err := uiServer.UserData(ctx); err != nil {
+		slog.Warn("failed to load user data", "error", err)
+	}
+
+	// Start the UI server
+	slog.Info("starting ui server", "port", port)
+	go func() {
+		slog.Debug("starting ui server on port", "port", port)
+		err = srv.Serve(ln)
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			slog.Warn("desktop server", "error", err)
+		}
+		slog.Debug("background desktop server done")
+	}()
+
+	updater := &updater.Updater{Store: st}
+	updater.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
+
+	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
+	if err != nil {
+		slog.Error("failed to load has completed first run", "error", err)
+	}
+
+	if !hasCompletedFirstRun {
+		err = st.SetHasCompletedFirstRun(true)
+		if err != nil {
+			slog.Error("failed to set has completed first run", "error", err)
+		}
+	}
+
+	// capture SIGINT and SIGTERM signals and gracefully shutdown the app
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-signals
+		slog.Info("received SIGINT or SIGTERM signal, shutting down")
+		quit()
+	}()
+
+	if urlSchemeRequest != "" {
+		go func() {
+			handleURLSchemeInCurrentInstance(urlSchemeRequest)
+		}()
+	} else {
+		slog.Debug("no URL scheme request to handle")
+	}
+
+	osRun(cancel, hasCompletedFirstRun, startHidden)
+
+	slog.Info("shutting down desktop server")
+	if err := srv.Close(); err != nil {
+		slog.Warn("error shutting down desktop server", "error", err)
+	}
+
+	slog.Info("shutting down ollama server")
+	cancel()
+	<-done
+}
+
+func startHiddenTasks() {
+	// If an upgrade is ready and we're in hidden mode, perform it at startup.
+	// If we're not in hidden mode, we want to start as fast as possible and not
+	// slow the user down with an upgrade.
+	if updater.IsUpdatePending() {
+		if fastStartup {
+			// CLI triggered app startup use-case
+			slog.Info("deferring pending update for fast startup")
+		} else {
+			if err := updater.DoUpgradeAtStartup(); err != nil {
+				slog.Info("unable to perform upgrade at startup", "error", err)
+				// Make sure the restart to upgrade menu shows so we can attempt an interactive upgrade to get authorization
+				UpdateAvailable("")
+			} else {
+				slog.Debug("launching new version...")
+				// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+				LaunchNewApp()
+				os.Exit(0)
+			}
+		}
+	}
+}
+
+func checkUserLoggedIn(uiServerPort int) bool {
+	if uiServerPort == 0 {
+		slog.Debug("UI server not ready yet, skipping auth check")
+		return false
+	}
+
+	resp, err := http.Get(fmt.Sprintf("http://127.0.0.1:%d/api/v1/me", uiServerPort))
+	if err != nil {
+		slog.Debug("failed to call local auth endpoint", "error", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	// Check if the response is successful
+	if resp.StatusCode != http.StatusOK {
+		slog.Debug("auth endpoint returned non-OK status", "status", resp.StatusCode)
+		return false
+	}
+
+	var user struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+		slog.Debug("failed to parse user response", "error", err)
+		return false
+	}
+
+	// Verify we have a valid user with an ID and name
+	if user.ID == "" || user.Name == "" {
+		slog.Debug("user response missing required fields", "id", user.ID, "name", user.Name)
+		return false
+	}
+
+	slog.Debug("user is logged in", "user_id", user.ID, "user_name", user.Name)
+	return true
+}
+
+// handleConnectURLScheme fetches the connect URL and opens it in the browser
+func handleConnectURLScheme() {
+	if checkUserLoggedIn(uiServerPort) {
+		slog.Info("user is already logged in, opening settings instead")
+		sendUIRequestMessage("/")
+		return
+	}
+
+	connectURL, err := auth.BuildConnectURL("https://ollama.com")
+	if err != nil {
+		slog.Error("failed to build connect URL", "error", err)
+		openInBrowser("https://ollama.com/connect")
+		return
+	}
+
+	openInBrowser(connectURL)
+}
+
+// openInBrowser opens the specified URL in the default browser
+func openInBrowser(url string) {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "rundll32"
+		args = []string{"url.dll,FileProtocolHandler", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"... should not reach here
+		slog.Warn("unsupported OS for openInBrowser", "os", runtime.GOOS)
+	}
+
+	slog.Info("executing browser command", "cmd", cmd, "args", args)
+	if err := exec.Command(cmd, args...).Start(); err != nil {
+		slog.Error("failed to open URL in browser", "url", url, "cmd", cmd, "args", args, "error", err)
+	}
+}
+
+// parseURLScheme parses an ollama:// URL and returns whether it's a connect URL and the UI path
+func parseURLScheme(urlSchemeRequest string) (isConnect bool, uiPath string, err error) {
+	parsedURL, err := url.Parse(urlSchemeRequest)
+	if err != nil {
+		return false, "", err
+	}
+
+	// Check if this is a connect URL
+	if parsedURL.Host == "connect" || strings.TrimPrefix(parsedURL.Path, "/") == "connect" {
+		return true, "", nil
+	}
+
+	// Extract the UI path
+	path := "/"
+	if parsedURL.Path != "" && parsedURL.Path != "/" {
+		// For URLs like ollama:///settings, use the path directly
+		path = parsedURL.Path
+	} else if parsedURL.Host != "" {
+		// For URLs like ollama://settings (without triple slash),
+		// the "settings" part is parsed as the host, not the path.
+		// We need to convert it to a path by prepending "/"
+		// This also handles ollama://settings/ where Windows adds a trailing slash
+		path = "/" + parsedURL.Host
+	}
+
+	return false, path, nil
+}
+
+// handleURLSchemeInCurrentInstance processes URL scheme requests in the current instance
+func handleURLSchemeInCurrentInstance(urlSchemeRequest string) {
+	isConnect, uiPath, err := parseURLScheme(urlSchemeRequest)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		sendUIRequestMessage(uiPath)
+	}
+}
--- a/app/cmd/app/app_darwin.go
+++ b/app/cmd/app/app_darwin.go
@@ -0,0 +1,269 @@
+//go:build windows || darwin
+
+package main
+
+// #cgo CFLAGS: -x objective-c
+// #cgo LDFLAGS: -framework Webkit -framework Cocoa -framework LocalAuthentication -framework ServiceManagement
+// #include "app_darwin.h"
+// #include "../../updater/updater_darwin.h"
+// typedef const char cchar_t;
+import "C"
+
+import (
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var ollamaPath = func() string {
+	if updater.BundlePath != "" {
+		return filepath.Join(updater.BundlePath, "Contents", "Resources", "ollama")
+	}
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		slog.Warn("failed to get pwd", "error", err)
+		return ""
+	}
+	return filepath.Join(pwd, "ollama")
+}()
+
+var (
+	isApp           = updater.BundlePath != ""
+	appLogPath      = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "app.log")
+	launchAgentPath = filepath.Join(os.Getenv("HOME"), "Library", "LaunchAgents", "com.ollama.ollama.plist")
+)
+
+// TODO(jmorganca): pre-create the window and pass
+// it to the webview instead of using the internal one
+//
+//export StartUI
+func StartUI(path *C.cchar_t) {
+	p := C.GoString(path)
+	wv.Run(p)
+	styleWindow(wv.webview.Window())
+	C.setWindowDelegate(wv.webview.Window())
+}
+
+//export ShowUI
+func ShowUI() {
+	// If webview is already running, just show the window
+	if wv.IsRunning() && wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		root := C.CString("/")
+		defer C.free(unsafe.Pointer(root))
+		StartUI(root)
+	}
+}
+
+//export StopUI
+func StopUI() {
+	wv.Terminate()
+}
+
+//export StartUpdate
+func StartUpdate() {
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Error("upgrade failed", "error", err)
+		return
+	}
+	slog.Debug("launching new version...")
+	// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+	LaunchNewApp()
+	// not reached if upgrade works, the new app will kill this process
+}
+
+//export darwinStartHiddenTasks
+func darwinStartHiddenTasks() {
+	startHiddenTasks()
+}
+
+func init() {
+	// Temporary code to mimic Squirrel ShipIt behavior
+	if len(os.Args) > 2 {
+		if os.Args[1] == "___launch___" {
+			path := strings.TrimPrefix(os.Args[2], "file://")
+			slog.Info("Ollama binary called as ShipIt - launching", "app", path)
+			appName := C.CString(path)
+			defer C.free(unsafe.Pointer(appName))
+			C.launchApp(appName)
+			slog.Info("other instance has been launched")
+			time.Sleep(5 * time.Second)
+			slog.Info("exiting with zero status")
+			os.Exit(0)
+		}
+	}
+}
+
+// maybeMoveAndRestart checks if we should relocate
+// and returns true if we did and should immediately exit
+func maybeMoveAndRestart() appMove {
+	if updater.BundlePath == "" {
+		// Typically developer mode with 'go run ./cmd/app'
+		return CannotMove
+	}
+	// Respect users intent if they chose "keep" vs. "replace" when dragging to Applications
+	if strings.HasPrefix(updater.BundlePath, strings.TrimSuffix(updater.SystemWidePath, filepath.Ext(updater.SystemWidePath))) {
+		return AlreadyMoved
+	}
+
+	// Ask to move to applications directory
+	status := (appMove)(C.askToMoveToApplications())
+	if status == MoveCompleted {
+		// Double check
+		if _, err := os.Stat(updater.SystemWidePath); err != nil {
+			slog.Warn("stat failure after move", "path", updater.SystemWidePath, "error", err)
+			return MoveError
+		}
+	}
+	return status
+}
+
+// handleExistingInstance handles existing instances on macOS
+func handleExistingInstance(_ bool) {
+	C.killOtherInstances()
+}
+
+func installSymlink() {
+	if !isApp {
+		return
+	}
+	cliPath := C.CString(ollamaPath)
+	defer C.free(unsafe.Pointer(cliPath))
+
+	// Check the users path first
+	cmd, _ := exec.LookPath("ollama")
+	if cmd != "" {
+		resolved, err := os.Readlink(cmd)
+		if err == nil {
+			tmp, err := filepath.Abs(resolved)
+			if err == nil {
+				resolved = tmp
+			}
+		} else {
+			resolved = cmd
+		}
+		if resolved == ollamaPath {
+			slog.Info("ollama already in users PATH", "cli", cmd)
+			return
+		}
+	}
+
+	code := C.installSymlink(cliPath)
+	if code != 0 {
+		slog.Error("Failed to install symlink")
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	slog.Debug("update detected, adjusting menu")
+	// TODO (jmorganca): find a better check for development mode than checking the bundle path
+	if updater.BundlePath != "" {
+		C.updateAvailable()
+	}
+	return nil
+}
+
+func osRun(_ func(), hasCompletedFirstRun, startHidden bool) {
+	registerLaunchAgent(hasCompletedFirstRun)
+
+	// Run the native macOS app
+	// Note: this will block until the app is closed
+	slog.Debug("starting native darwin event loop")
+	C.run(C._Bool(hasCompletedFirstRun), C._Bool(startHidden))
+}
+
+func quit() {
+	C.quit()
+}
+
+func LaunchNewApp() {
+	appName := C.CString(updater.BundlePath)
+	defer C.free(unsafe.Pointer(appName))
+	C.launchApp(appName)
+}
+
+// Send a request to the main app thread to load a UI page
+func sendUIRequestMessage(path string) {
+	p := C.CString(path)
+	defer C.free(unsafe.Pointer(p))
+	C.uiRequest(p)
+}
+
+func registerLaunchAgent(hasCompletedFirstRun bool) {
+	// Remove any stale Login Item registrations
+	C.unregisterSelfFromLoginItem()
+
+	C.registerSelfAsLoginItem(C._Bool(hasCompletedFirstRun))
+}
+
+func logStartup() {
+	appPath := updater.BundlePath
+	if appPath == updater.SystemWidePath {
+		// Detect sandboxed scenario
+		exe, err := os.Executable()
+		if err == nil {
+			p := filepath.Dir(exe)
+			if filepath.Base(p) == "MacOS" {
+				p = filepath.Dir(filepath.Dir(p))
+				if p != appPath {
+					slog.Info("starting sandboxed Ollama", "app", appPath, "sandbox", p)
+					return
+				}
+			}
+		}
+	}
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+func hideWindow(ptr unsafe.Pointer) {
+	C.hideWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	C.showWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func styleWindow(ptr unsafe.Pointer) {
+	C.styleWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func runInBackground() {
+	cmd := exec.Command(filepath.Join(updater.BundlePath, "Contents", "MacOS", "Ollama"), "hidden")
+	if cmd != nil {
+		err := cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "bundlePath", updater.BundlePath, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama in background", "bundlePath", updater.BundlePath)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {
+	C.drag(C.uintptr_t(uintptr(ptr)))
+}
+
+func doubleClick(ptr unsafe.Pointer) {
+	C.doubleClick(C.uintptr_t(uintptr(ptr)))
+}
+
+//export handleConnectURL
+func handleConnectURL() {
+	handleConnectURLScheme()
+}
+
+// checkAndHandleExistingInstance is not needed on non-Windows platforms
+func checkAndHandleExistingInstance(_ string) bool {
+	return false
+}
--- a/app/cmd/app/app_darwin.h
+++ b/app/cmd/app/app_darwin.h
@@ -0,0 +1,43 @@
+#import <Cocoa/Cocoa.h>
+#import <Security/Security.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+@end
+
+enum AppMove
+{
+    CannotMove,
+    UserDeclinedMove,
+    MoveCompleted,
+    AlreadyMoved,
+    LoginSession,
+    PermissionDenied,
+    MoveError,
+};
+
+void run(bool firstTimeRun, bool startHidden);
+void killOtherInstances();
+enum AppMove askToMoveToApplications();
+int createSymlinkWithAuthorization();
+int installSymlink(const char *cliPath);
+extern void Restart();
+// extern void Quit();
+void StartUI(const char *path);
+void ShowUI();
+void StopUI();
+void StartUpdate();
+void darwinStartHiddenTasks();
+void launchApp(const char *appPath);
+void updateAvailable();
+void quit();
+void uiRequest(char *path);
+void registerSelfAsLoginItem(bool firstTimeRun);
+void unregisterSelfFromLoginItem();
+void setWindowDelegate(void *window);
+void showWindow(uintptr_t wndPtr);
+void hideWindow(uintptr_t wndPtr);
+void styleWindow(uintptr_t wndPtr);
+void drag(uintptr_t wndPtr);
+void doubleClick(uintptr_t wndPtr);
+void handleConnectURL();
--- a/app/cmd/app/app_darwin.m
+++ b/app/cmd/app/app_darwin.m
--- a/app/cmd/app/app_windows.go
+++ b/app/cmd/app/app_windows.go
@@ -0,0 +1,439 @@
+//go:build windows || darwin
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"log/slog"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+	"github.com/ollama/ollama/app/wintray"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	u32                  = windows.NewLazySystemDLL("User32.dll")
+	pBringWindowToTop    = u32.NewProc("BringWindowToTop")
+	pShowWindow          = u32.NewProc("ShowWindow")
+	pSendMessage         = u32.NewProc("SendMessageA")
+	pGetSystemMetrics    = u32.NewProc("GetSystemMetrics")
+	pGetWindowRect       = u32.NewProc("GetWindowRect")
+	pSetWindowPos        = u32.NewProc("SetWindowPos")
+	pSetForegroundWindow = u32.NewProc("SetForegroundWindow")
+	pSetActiveWindow     = u32.NewProc("SetActiveWindow")
+	pIsIconic            = u32.NewProc("IsIconic")
+
+	appPath         = filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", "Ollama")
+	appLogPath      = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "app.log")
+	startupShortcut = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "Ollama.lnk")
+	ollamaPath      string
+	DesktopAppName  = "ollama app.exe"
+)
+
+func init() {
+	// With alternate install location use executable location
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Warn("error discovering executable directory", "error", err)
+	} else {
+		appPath = filepath.Dir(exe)
+	}
+	ollamaPath = filepath.Join(appPath, "ollama.exe")
+
+	// Handle developer mode (go run ./cmd/app)
+	if _, err := os.Stat(ollamaPath); err != nil {
+		pwd, err := os.Getwd()
+		if err != nil {
+			slog.Warn("missing ollama.exe and failed to get pwd", "error", err)
+			return
+		}
+		distAppPath := filepath.Join(pwd, "dist", "windows-"+runtime.GOARCH)
+		distOllamaPath := filepath.Join(distAppPath, "ollama.exe")
+		if _, err := os.Stat(distOllamaPath); err == nil {
+			slog.Info("detected developer mode")
+			appPath = distAppPath
+			ollamaPath = distOllamaPath
+		}
+	}
+}
+
+func maybeMoveAndRestart() appMove {
+	return 0
+}
+
+// handleExistingInstance checks for existing instances and optionally focuses them
+func handleExistingInstance(startHidden bool) {
+	if wintray.CheckAndFocusExistingInstance(!startHidden) {
+		slog.Info("existing instance found, exiting")
+		os.Exit(0)
+	}
+}
+
+func installSymlink() {}
+
+type appCallbacks struct {
+	t        wintray.TrayCallbacks
+	shutdown func()
+}
+
+var app = &appCallbacks{}
+
+func (ac *appCallbacks) UIRun(path string) {
+	wv.Run(path)
+}
+
+func (*appCallbacks) UIShow() {
+	if wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		wv.Run("/")
+	}
+}
+
+func (*appCallbacks) UITerminate() {
+	wv.Terminate()
+}
+
+func (*appCallbacks) UIRunning() bool {
+	return wv.IsRunning()
+}
+
+func (app *appCallbacks) Quit() {
+	app.t.Quit()
+	wv.Terminate()
+}
+
+// TODO - reconcile with above for consistency between mac/windows
+func quit() {
+	wv.Terminate()
+}
+
+func (app *appCallbacks) DoUpdate() {
+	// Safeguard in case we have requests in flight that need to drain...
+	slog.Info("Waiting for server to shutdown")
+
+	app.shutdown()
+
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
+	}
+}
+
+// HandleURLScheme implements the URLSchemeHandler interface
+func (app *appCallbacks) HandleURLScheme(urlScheme string) {
+	handleURLSchemeRequest(urlScheme)
+}
+
+// handleURLSchemeRequest processes URL scheme requests from other instances
+func handleURLSchemeRequest(urlScheme string) {
+	isConnect, uiPath, err := parseURLScheme(urlScheme)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlScheme, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		sendUIRequestMessage(uiPath)
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	return app.t.UpdateAvailable(ver)
+}
+
+func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
+	var err error
+	app.shutdown = shutdown
+	app.t, err = wintray.NewTray(app)
+	if err != nil {
+		log.Fatalf("Failed to start: %s", err)
+	}
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+
+	// TODO - can this be generalized?
+	go func() {
+		<-signals
+		slog.Debug("shutting down due to signal")
+		app.t.Quit()
+		wv.Terminate()
+	}()
+
+	// On windows, we run the final tasks in the main thread
+	// before starting the tray event loop.  These final tasks
+	// may trigger the UI, and must do that from the main thread.
+	if !startHidden {
+		// Determine if the process was started from a shortcut
+		// ~\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Ollama
+		const STARTF_TITLEISLINKNAME = 0x00000800
+		var info windows.StartupInfo
+		if err := windows.GetStartupInfo(&info); err != nil {
+			slog.Debug("unable to retrieve startup info", "error", err)
+		} else if info.Flags&STARTF_TITLEISLINKNAME == STARTF_TITLEISLINKNAME {
+			linkPath := windows.UTF16PtrToString(info.Title)
+			if strings.Contains(linkPath, "Startup") {
+				startHidden = true
+			}
+		}
+	}
+	if startHidden {
+		startHiddenTasks()
+	} else {
+		ptr := wv.Run("/")
+
+		// Set the window icon using the tray icon
+		if ptr != nil {
+			iconHandle := app.t.GetIconHandle()
+			if iconHandle != 0 {
+				hwnd := uintptr(ptr)
+				const ICON_SMALL = 0
+				const ICON_BIG = 1
+				const WM_SETICON = 0x0080
+
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+			}
+		}
+
+		centerWindow(ptr)
+	}
+
+	if !hasCompletedFirstRun {
+		// Only create the login shortcut on first start
+		// so we can respect users deletion of the link
+		err = createLoginShortcut()
+		if err != nil {
+			slog.Warn("unable to create login shortcut", "error", err)
+		}
+	}
+
+	app.t.TrayRun() // This will block the main thread
+}
+
+func createLoginShortcut() error {
+	// The installer lays down a shortcut for us so we can copy it without
+	// having to resort to calling COM APIs to establish the shortcut
+	shortcutOrigin := filepath.Join(appPath, "lib", "Ollama.lnk")
+
+	_, err := os.Stat(startupShortcut)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			in, err := os.Open(shortcutOrigin)
+			if err != nil {
+				return fmt.Errorf("unable to open shortcut %s : %w", shortcutOrigin, err)
+			}
+			defer in.Close()
+			out, err := os.Create(startupShortcut)
+			if err != nil {
+				return fmt.Errorf("unable to open startup link %s : %w", startupShortcut, err)
+			}
+			defer out.Close()
+			_, err = io.Copy(out, in)
+			if err != nil {
+				return fmt.Errorf("unable to copy shortcut %s : %w", startupShortcut, err)
+			}
+			err = out.Sync()
+			if err != nil {
+				return fmt.Errorf("unable to sync shortcut %s : %w", startupShortcut, err)
+			}
+			slog.Info("Created Startup shortcut", "shortcut", startupShortcut)
+		} else {
+			slog.Warn("unexpected error looking up Startup shortcut", "error", err)
+		}
+	} else {
+		slog.Debug("Startup link already exists", "shortcut", startupShortcut)
+	}
+	return nil
+}
+
+// Send a request to the main app thread to load a UI page
+func sendUIRequestMessage(path string) {
+	wintray.SendUIRequestMessage(path)
+}
+
+func LaunchNewApp() {
+}
+
+func logStartup() {
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+const (
+	SW_HIDE        = 0  // Hides the window
+	SW_SHOW        = 5  // Shows window in its current size/position
+	SW_SHOWNA      = 8  // Shows without activating
+	SW_MINIMIZE    = 6  // Minimizes the window
+	SW_RESTORE     = 9  // Restores to previous size/position
+	SW_SHOWDEFAULT = 10 // Sets show state based on program state
+	SM_CXSCREEN    = 0
+	SM_CYSCREEN    = 1
+	HWND_TOP       = 0
+	SWP_NOSIZE     = 0x0001
+	SWP_NOMOVE     = 0x0002
+	SWP_NOZORDER   = 0x0004
+	SWP_SHOWWINDOW = 0x0040
+
+	// Menu constants
+	MF_STRING     = 0x00000000
+	MF_SEPARATOR  = 0x00000800
+	MF_GRAYED     = 0x00000001
+	TPM_RETURNCMD = 0x0100
+)
+
+// POINT structure for cursor position
+type POINT struct {
+	X int32
+	Y int32
+}
+
+// Rect structure for GetWindowRect
+type Rect struct {
+	Left   int32
+	Top    int32
+	Right  int32
+	Bottom int32
+}
+
+func centerWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd == 0 {
+		return
+	}
+
+	var rect Rect
+	pGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&rect)))
+
+	screenWidth, _, _ := pGetSystemMetrics.Call(uintptr(SM_CXSCREEN))
+	screenHeight, _, _ := pGetSystemMetrics.Call(uintptr(SM_CYSCREEN))
+
+	windowWidth := rect.Right - rect.Left
+	windowHeight := rect.Bottom - rect.Top
+
+	x := (int32(screenWidth) - windowWidth) / 2
+	y := (int32(screenHeight) - windowHeight) / 2
+
+	// Ensure the window is not positioned off-screen
+	if x < 0 {
+		x = 0
+	}
+	if y < 0 {
+		y = 0
+	}
+
+	pSetWindowPos.Call(
+		hwnd,
+		uintptr(HWND_TOP),
+		uintptr(x),
+		uintptr(y),
+		uintptr(windowWidth),  // Keep original width
+		uintptr(windowHeight), // Keep original height
+		uintptr(SWP_SHOWWINDOW),
+	)
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		iconHandle := app.t.GetIconHandle()
+		if iconHandle != 0 {
+			const ICON_SMALL = 0
+			const ICON_BIG = 1
+			const WM_SETICON = 0x0080
+
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+		}
+
+		// Check if window is minimized
+		isMinimized, _, _ := pIsIconic.Call(hwnd)
+		if isMinimized != 0 {
+			// Restore the window if it's minimized
+			pShowWindow.Call(hwnd, uintptr(SW_RESTORE))
+		}
+
+		// Show the window
+		pShowWindow.Call(hwnd, uintptr(SW_SHOW))
+
+		// Bring window to top
+		pBringWindowToTop.Call(hwnd)
+
+		// Force window to foreground
+		pSetForegroundWindow.Call(hwnd)
+
+		// Make it the active window
+		pSetActiveWindow.Call(hwnd)
+
+		// Ensure window is positioned on top
+		pSetWindowPos.Call(
+			hwnd,
+			uintptr(HWND_TOP),
+			0, 0, 0, 0,
+			uintptr(SWP_NOSIZE|SWP_NOMOVE|SWP_SHOWWINDOW),
+		)
+	}
+}
+
+// HideWindow hides the application window
+func hideWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		pShowWindow.Call(
+			hwnd,
+			uintptr(SW_HIDE),
+		)
+	}
+}
+
+func runInBackground() {
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Error("failed to get executable path", "error", err)
+		os.Exit(1)
+	}
+	cmd := exec.Command(exe, "hidden")
+	if cmd != nil {
+		err = cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "exe", exe, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama", "exe", exe)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {}
+
+func doubleClick(ptr unsafe.Pointer) {}
+
+// checkAndHandleExistingInstance checks if another instance is running and sends the URL to it
+func checkAndHandleExistingInstance(urlSchemeRequest string) bool {
+	if urlSchemeRequest == "" {
+		return false
+	}
+
+	// Try to send URL to existing instance using wintray messaging
+	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
+		os.Exit(0)
+		return true
+	}
+
+	// No existing instance, we'll handle it ourselves
+	return false
+}
--- a/app/cmd/app/menu.h
+++ b/app/cmd/app/menu.h
@@ -0,0 +1,27 @@
+#ifndef MENU_H
+#define MENU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    char *label;
+    int enabled;
+    int separator;
+} menuItem;
+
+// TODO (jmorganca): these need to be forward declared in the webview.h file
+// for now but ideally they should be in this header file on windows too
+#ifndef WIN32
+int menu_get_item_count();
+void *menu_get_items();
+void menu_handle_selection(char *item);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/app/cmd/app/webview.go
+++ b/app/cmd/app/webview.go
@@ -0,0 +1,528 @@
+//go:build windows || darwin
+
+package main
+
+// #include "menu.h"
+import "C"
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/dialog"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/webview"
+)
+
+type Webview struct {
+	port    int
+	token   string
+	webview webview.WebView
+	mutex   sync.Mutex
+
+	Store *store.Store
+}
+
+// Run initializes the webview and starts its event loop.
+// Note: this must be called from the primary app thread
+// This returns the OS native window handle to the caller
+func (w *Webview) Run(path string) unsafe.Pointer {
+	var url string
+	if devMode {
+		// In development mode, use the local dev server
+		url = fmt.Sprintf("http://localhost:5173%s", path)
+	} else {
+		url = fmt.Sprintf("http://127.0.0.1:%d%s", w.port, path)
+	}
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	if w.webview == nil {
+		// Note: turning on debug on macos throws errors but is marginally functional for debugging
+		// TODO (jmorganca): we should pre-create the window and then provide it here to
+		// webview so we can hide it from the start and make other modifications
+		wv := webview.New(debug)
+		// start the window hidden
+		hideWindow(wv.Window())
+		wv.SetTitle("Ollama")
+
+		// TODO (jmorganca): this isn't working yet since it needs to be set
+		// on the first page load, ideally in an interstitial page like `/token`
+		// that exists only to set the cookie and redirect to /
+		// wv.Init(fmt.Sprintf(`document.cookie = "token=%s; path=/"`, w.token))
+		init := `
+		// Disable reload
+		document.addEventListener('keydown', function(e) {
+			if ((e.ctrlKey || e.metaKey) && e.key === 'r') {
+				e.preventDefault();
+				return false;
+			}
+		});
+
+		// Prevent back/forward navigation
+		window.addEventListener('popstate', function(e) {
+			e.preventDefault();
+			history.pushState(null, '', window.location.pathname);
+			return false;
+		});
+
+		// Clear history on load
+		window.addEventListener('load', function() {
+			history.pushState(null, '', window.location.pathname);
+			window.history.replaceState(null, '', window.location.pathname);
+		});
+
+		// Set token cookie
+		document.cookie = "token=` + w.token + `; path=/";
+	`
+		// Windows-specific scrollbar styling
+		if runtime.GOOS == "windows" {
+			init += `
+				// Fix scrollbar styling for Edge WebView2 on Windows only
+				function updateScrollbarStyles() {
+					const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+					const existingStyle = document.getElementById('scrollbar-style');
+					if (existingStyle) existingStyle.remove();
+					
+					const style = document.createElement('style');
+					style.id = 'scrollbar-style';
+					
+					if (isDark) {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #1a1a1a !important; }
+							::-webkit-scrollbar-thumb { background: #404040 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #505050 !important; }
+							::-webkit-scrollbar-corner { background: #1a1a1a !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					} else {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
+							::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					}
+					document.head.appendChild(style);
+				}
+				
+				window.addEventListener('load', updateScrollbarStyles);
+				window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', updateScrollbarStyles);
+			`
+		}
+		// on windows make ctrl+n open new chat
+		// TODO (jmorganca): later we should use proper accelerators
+		// once we introduce a native menu for the window
+		// this is only used on windows since macOS uses the proper accelerators
+		if runtime.GOOS == "windows" {
+			init += `
+				document.addEventListener('keydown', function(e) {
+					if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
+						e.preventDefault();
+						// Use the existing navigation method
+						history.pushState({}, '', '/c/new');
+						window.dispatchEvent(new PopStateEvent('popstate'));
+						return false;
+					}
+				});
+			`
+		}
+
+		init += `
+			window.OLLAMA_WEBSEARCH = true;
+		`
+
+		wv.Init(init)
+
+		// Add keyboard handler for zoom
+		wv.Init(`
+			window.addEventListener('keydown', function(e) {
+				// CMD/Ctrl + Plus/Equals (zoom in)
+				if ((e.metaKey || e.ctrlKey) && (e.key === '+' || e.key === '=')) {
+					e.preventDefault();
+					window.zoomIn && window.zoomIn();
+					return false;
+				}
+
+				// CMD/Ctrl + Minus (zoom out)
+				if ((e.metaKey || e.ctrlKey) && e.key === '-') {
+					e.preventDefault();
+					window.zoomOut && window.zoomOut();
+					return false;
+				}
+
+				// CMD/Ctrl + 0 (reset zoom)
+				if ((e.metaKey || e.ctrlKey) && e.key === '0') {
+					e.preventDefault();
+					window.zoomReset && window.zoomReset();
+					return false;
+				}
+			}, true);
+		`)
+
+		wv.Bind("zoomIn", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current + 0.1)
+		})
+
+		wv.Bind("zoomOut", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current - 0.1)
+		})
+
+		wv.Bind("zoomReset", func() {
+			wv.SetZoom(1.0)
+		})
+
+		wv.Bind("ready", func() {
+			showWindow(wv.Window())
+		})
+
+		wv.Bind("close", func() {
+			hideWindow(wv.Window())
+		})
+
+		// Webviews do not allow access to the file system by default, so we need to
+		// bind file system operations here
+		wv.Bind("selectModelsDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectModelsDirectoryCallback && window.__selectModelsDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Model Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		// Bind selectFiles function for selecting multiple files at once
+		wv.Bind("selectFiles", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectFilesCallback && window.__selectFilesCallback(%s)", dataJSON))
+					})
+				}
+
+				// Define allowed extensions for native dialog filtering
+				textExts := []string{
+					"pdf", "docx", "txt", "md", "csv", "json", "xml", "html", "htm",
+					"js", "jsx", "ts", "tsx", "py", "java", "cpp", "c", "cc", "h", "cs", "php", "rb",
+					"go", "rs", "swift", "kt", "scala", "sh", "bat", "yaml", "yml", "toml", "ini",
+					"cfg", "conf", "log", "rtf",
+				}
+				imageExts := []string{"png", "jpg", "jpeg"}
+				allowedExts := append(textExts, imageExts...)
+
+				// Use native multiple file selection with extension filtering
+				filenames, err := dialog.File().
+					Filter("Supported Files", allowedExts...).
+					Title("Select Files").
+					LoadMultiple()
+				if err != nil {
+					slog.Debug("Multiple file selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+
+				if len(filenames) == 0 {
+					callCallback(nil)
+					return
+				}
+
+				var files []map[string]string
+				maxFileSize := int64(10 * 1024 * 1024) // 10MB
+
+				for _, filename := range filenames {
+					// Check file extension (double-check after native dialog filtering)
+					ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
+					validExt := false
+					for _, allowedExt := range allowedExts {
+						if ext == allowedExt {
+							validExt = true
+							break
+						}
+					}
+					if !validExt {
+						slog.Warn("file extension not allowed, skipping", "filename", filepath.Base(filename), "extension", ext)
+						continue
+					}
+
+					// Check file size before reading (pre-filter large files)
+					fileStat, err := os.Stat(filename)
+					if err != nil {
+						slog.Error("failed to get file info", "error", err, "filename", filename)
+						continue
+					}
+
+					if fileStat.Size() > maxFileSize {
+						slog.Warn("file too large, skipping", "filename", filepath.Base(filename), "size", fileStat.Size())
+						continue
+					}
+
+					fileBytes, err := os.ReadFile(filename)
+					if err != nil {
+						slog.Error("failed to read file", "error", err, "filename", filename)
+						continue
+					}
+
+					mimeType := http.DetectContentType(fileBytes)
+					dataURL := fmt.Sprintf("data:%s;base64,%s", mimeType, base64.StdEncoding.EncodeToString(fileBytes))
+
+					fileResult := map[string]string{
+						"filename": filepath.Base(filename),
+						"path":     filename,
+						"dataURL":  dataURL,
+					}
+
+					files = append(files, fileResult)
+				}
+
+				if len(files) == 0 {
+					callCallback(nil)
+				} else {
+					callCallback(files)
+				}
+			}()
+		})
+
+		wv.Bind("drag", func() {
+			wv.Dispatch(func() {
+				drag(wv.Window())
+			})
+		})
+
+		wv.Bind("doubleClick", func() {
+			wv.Dispatch(func() {
+				doubleClick(wv.Window())
+			})
+		})
+
+		// Add binding for working directory selection
+		wv.Bind("selectWorkingDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectWorkingDirectoryCallback && window.__selectWorkingDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Working Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		wv.Bind("setContextMenuItems", func(items []map[string]interface{}) error {
+			menuMutex.Lock()
+			defer menuMutex.Unlock()
+
+			if len(menuItems) > 0 {
+				pinner.Unpin()
+			}
+
+			menuItems = nil
+			for _, item := range items {
+				menuItem := C.menuItem{
+					label:     C.CString(item["label"].(string)),
+					enabled:   0,
+					separator: 0,
+				}
+
+				if item["enabled"] != nil {
+					menuItem.enabled = 1
+				}
+
+				if item["separator"] != nil {
+					menuItem.separator = 1
+				}
+				menuItems = append(menuItems, menuItem)
+			}
+			return nil
+		})
+
+		// Debounce resize events
+		var resizeTimer *time.Timer
+		var resizeMutex sync.Mutex
+
+		wv.Bind("resize", func(width, height int) {
+			if w.Store != nil {
+				resizeMutex.Lock()
+				if resizeTimer != nil {
+					resizeTimer.Stop()
+				}
+				resizeTimer = time.AfterFunc(100*time.Millisecond, func() {
+					err := w.Store.SetWindowSize(width, height)
+					if err != nil {
+						slog.Error("failed to set window size", "error", err)
+					}
+				})
+				resizeMutex.Unlock()
+			}
+		})
+
+		// On Darwin, we can't have 2 threads both running global event loops
+		// but on Windows, the event loops are tied to the window, so we're
+		// able to run in both the tray and webview
+		if runtime.GOOS != "darwin" {
+			slog.Debug("starting webview event loop")
+			go func() {
+				wv.Run()
+				slog.Debug("webview event loop exited")
+			}()
+		}
+
+		if w.Store != nil {
+			width, height, err := w.Store.WindowSize()
+			if err != nil {
+				slog.Error("failed to get window size", "error", err)
+			}
+			if width > 0 && height > 0 {
+				wv.SetSize(width, height, webview.HintNone)
+			} else {
+				wv.SetSize(800, 600, webview.HintNone)
+			}
+		}
+		wv.SetSize(800, 600, webview.HintMin)
+
+		w.webview = wv
+		w.webview.Navigate(url)
+	} else {
+		w.webview.Eval(fmt.Sprintf(`
+			history.pushState({}, '', '%s');
+		`, path))
+		showWindow(w.webview.Window())
+	}
+
+	return w.webview.Window()
+}
+
+func (w *Webview) Terminate() {
+	w.mutex.Lock()
+	if w.webview == nil {
+		w.mutex.Unlock()
+		return
+	}
+
+	wv := w.webview
+	w.webview = nil
+	w.mutex.Unlock()
+	wv.Terminate()
+	wv.Destroy()
+}
+
+func (w *Webview) IsRunning() bool {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+	return w.webview != nil
+}
+
+var (
+	menuItems []C.menuItem
+	menuMutex sync.RWMutex
+	pinner    runtime.Pinner
+)
+
+//export menu_get_item_count
+func menu_get_item_count() C.int {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+	return C.int(len(menuItems))
+}
+
+//export menu_get_items
+func menu_get_items() unsafe.Pointer {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+
+	if len(menuItems) == 0 {
+		return nil
+	}
+
+	// Return pointer to the slice data
+	pinner.Pin(&menuItems[0])
+	return unsafe.Pointer(&menuItems[0])
+}
+
+//export menu_handle_selection
+func menu_handle_selection(item *C.char) {
+	wv.webview.Eval(fmt.Sprintf("window.handleContextMenuResult('%s')", C.GoString(item)))
+}
--- a/app/cmd/squirrel/Info.plist
+++ b/app/cmd/squirrel/Info.plist
@@ -0,0 +1,40 @@
+<?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>CFBundleDevelopmentRegion</key>
+    <string>English</string>
+    <key>CFBundleExecutable</key>
+    <string>Squirrel</string>
+    <key>CFBundleIconFile</key>
+    <string/>
+    <key>CFBundleIdentifier</key>
+    <string>com.github.Squirrel</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Squirrel</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>DTCompiler</key>
+    <string>com.apple.compilers.llvm.clang.1_0</string>
+    <key>DTSDKBuild</key>
+    <string>22E245</string>
+    <key>DTSDKName</key>
+    <string>macosx13.3</string>
+    <key>DTXcode</key>
+    <string>1431</string>
+    <key>DTXcodeBuild</key>
+    <string>14E300c</string>
+    <key>NSHumanReadableCopyright</key>
+    <string>Copyright © 2013 GitHub. All rights reserved.</string>
+    <key>NSPrincipalClass</key>
+    <string/>
+  </dict>
+</plist>