Added winget install instructions

Author: akclace

README.md

@@ -228,11 +228,17 @@ brew services start openrun
 
 To install on Windows, run
 
+```
+winget install OpenRunDev.OpenRun
+```
+
+or use the install script:
+
 ```
 powershell -Command "irm https://openrun.dev/install.ps1 | iex"
 ```
 
-Start a new command window (to get the updated env) and run `openrun server start` to start the OpenRun service.
+Start a new command window (to get the updated env) and run `openrun server start` to start the OpenRun service. On the first start, OpenRun generates an admin password and prints it; note it down.
 
 ### Kubernetes Install
 

cmd/openrun/main.go

@@ -74,8 +74,9 @@ func globalFlags(globalConfig *types.GlobalConfig, clientConfig *types.ClientCon
 // Uses OPENRUN_HOME env if set. Otherwise uses binaries parent path. Setting OPENRUN_HOME is
 // the easiest way to configure. Uses some extra heuristics to help avoid having to setup
 // OPENRUN_HOME in the env, by using the binaries parent folder as the default.
-// On mac, looks for brew install locations also.
-func getConfigPath(cCtx *cli.Context) (string, string, bool, error) {
+// On mac, looks for brew install locations also. When nothing is found, falls back to
+// $HOME/openrun (the install script default), with homeDefaulted set to true.
+func getConfigPath(cCtx *cli.Context) (clHomeRet, configFileRet string, clHomeEnvSet, homeDefaulted bool, errRet error) {
 	configFile := cCtx.String(configFileFlagName)
 	clHome := os.Getenv(types.OPENRUN_HOME)
 	if configFile == "" {
@@ -86,21 +87,21 @@ func getConfigPath(cCtx *cli.Context) (string, string, bool, error) {
 	}
 	if clHome != "" {
 		// Found OPENRUN_HOME
-		return clHome, configFile, true, nil
+		return clHome, configFile, true, false, nil
 	}
 	if configFile != "" {
 		// OPENRUN_HOME not set and config file is set, use config dir path as OPENRUN_HOME
 		clHome = filepath.Dir(configFile)
-		return clHome, configFile, false, nil
+		return clHome, configFile, false, false, nil
 	}
 
 	binFile, err := os.Executable()
 	if err != nil {
-		return "", "", false, fmt.Errorf("unable to find executable path: %w", err)
+		return "", "", false, false, fmt.Errorf("unable to find executable path: %w", err)
 	}
 	binAbsolute, err := filepath.EvalSymlinks(binFile)
 	if err != nil {
-		return "", "", false, fmt.Errorf("unable to resolve symlink: %w", err)
+		return "", "", false, false, fmt.Errorf("unable to resolve symlink: %w", err)
 	}
 
 	binParent := filepath.Dir(binAbsolute)
@@ -112,34 +113,43 @@ func getConfigPath(cCtx *cli.Context) (string, string, bool, error) {
 	if system.FileExists(binParentConfig) && (strings.Contains(binParent, "openrun") || strings.Contains(binParent, "clhome")) {
 		// Config file found in parent directory of the executable, use that as path
 		// To avoid clobbering /usr, check if the path contains the string openrun/clhome
-		return binParent, binParentConfig, false, nil
+		return binParent, binParentConfig, false, false, nil
 	}
 
 	// Running `brew --prefix` would be another option
 	if runtime.GOOS == "darwin" { //nolint:staticcheck
 		// brew OSX specific checks
 		if system.FileExists("/opt/homebrew/etc/openrun.toml") {
-			return "/opt/homebrew/var/openrun", "/opt/homebrew/etc/openrun.toml", false, nil
+			return "/opt/homebrew/var/openrun", "/opt/homebrew/etc/openrun.toml", false, false, nil
 		} else if system.FileExists("/usr/local/etc/openrun.toml") {
-			return "/usr/local/var/openrun", "/usr/local/etc/openrun.toml", false, nil
+			return "/usr/local/var/openrun", "/usr/local/etc/openrun.toml", false, false, nil
 		}
 	} else if runtime.GOOS == "linux" {
 		// brew linux specific checks
 		if system.FileExists("/home/linuxbrew/.linuxbrew/etc/openrun.toml") {
-			return "/home/linuxbrew/.linuxbrew/var/openrun", "/home/linuxbrew/.linuxbrew/etc/openrun.toml", false, nil
+			return "/home/linuxbrew/.linuxbrew/var/openrun", "/home/linuxbrew/.linuxbrew/etc/openrun.toml", false, false, nil
 		} else if system.FileExists("/usr/local/etc/openrun.toml") {
-			return "/usr/local/var/openrun", "/usr/local/etc/openrun.toml", false, nil
+			return "/usr/local/var/openrun", "/usr/local/etc/openrun.toml", false, false, nil
 		} else if system.FileExists("/var/lib/openrun/openrun.toml") {
 			// Linux system level installation
-			return "/var/lib/openrun", "/var/lib/openrun/openrun.toml", false, nil
+			return "/var/lib/openrun", "/var/lib/openrun/openrun.toml", false, false, nil
 		}
 	}
-	return "", "", false, fmt.Errorf("unable to find OPENRUN_HOME or config file")
+
+	// Nothing configured or discovered: default to $HOME/openrun, the same
+	// location the install scripts use. Package managers like winget cannot
+	// run an install script, so this is the normal path for such installs
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", "", false, false, fmt.Errorf("unable to find OPENRUN_HOME or config file: %w", err)
+	}
+	defaultHome := filepath.Join(homeDir, "openrun")
+	return defaultHome, filepath.Join(defaultHome, "openrun.toml"), false, true, nil
 }
 
 func parseConfig(cCtx *cli.Context, globalConfig *types.GlobalConfig, clientConfig *types.ClientConfig, serverConfig *types.ServerConfig) error {
 	// Find OPENRUN_HOME and config file, update OPENRUN_HOME in env
-	clHome, filePath, clHomeEnvSet, err := getConfigPath(cCtx)
+	clHome, filePath, clHomeEnvSet, homeDefaulted, err := getConfigPath(cCtx)
 	if err != nil {
 		return err
 	}
@@ -149,13 +159,37 @@ func parseConfig(cCtx *cli.Context, globalConfig *types.GlobalConfig, clientConf
 	}
 	os.Setenv(types.OPENRUN_HOME, clHome) //nolint:errcheck
 
+	if homeDefaulted && !system.FileExists(filePath) {
+		if system.IsRunningAsService() {
+			// The default home resolves to the service account profile (e.g.
+			// C:\Windows\System32\config\systemprofile), not the installing
+			// user's home, and a bootstrapped admin password would be printed
+			// where nobody can see it. Fail fast instead of silently creating
+			// a second config under the service profile
+			return fmt.Errorf("no config file found (looked for %s): when running as an OS service, set OPENRUN_HOME in the service environment or register the service with --config-file", filePath)
+		}
+		if cCtx.Args().Get(0) == "server" && cCtx.Args().Get(1) == "start" {
+			// First server start with no config setup (e.g. installed through
+			// winget, which cannot run the install script): initialize the
+			// config with a generated admin password, like the install scripts do
+			if err := bootstrapConfigFile(clHome, filePath); err != nil {
+				return err
+			}
+		}
+	}
+
 	//fmt.Fprintf(os.Stderr, "Loading config file: %s, clHome %s\n", filePath, clHome)
 	buf, err := os.ReadFile(filePath)
 	if err != nil {
 		if clHomeEnvSet {
 			fmt.Fprintf(os.Stderr, "Warning: unable to read config file %s, using default config\n", err)
 			return nil
 		}
+		if homeDefaulted {
+			// No install setup found anywhere; run with the default config so
+			// commands like help and version work without any setup
+			return nil
+		}
 		return err
 	}
 

cmd/openrun/misc_cmds.go

@@ -76,6 +76,31 @@ func generatePassword(cCtx *cli.Context) error {
 	return nil
 }
 
+// bootstrapConfigFile creates the OPENRUN_HOME directory and an initial config
+// file with a generated admin password, mirroring what the install scripts do.
+// Used on the first server start when no config setup was found.
+func bootstrapConfigFile(clHome, configFile string) error {
+	if err := os.MkdirAll(clHome, 0o755); err != nil {
+		return fmt.Errorf("unable to create OPENRUN_HOME %s: %w", clHome, err)
+	}
+	password, err := passwd.GeneratePassword()
+	if err != nil {
+		return err
+	}
+	bcryptPassword, err := bcrypt.GenerateFromPassword([]byte(password), passwd.BCRYPT_COST)
+	if err != nil {
+		return err
+	}
+	contents := fmt.Sprintf("# Generated by openrun on first server start\n[security]\nadmin_password_bcrypt = \"%s\"\n", bcryptPassword)
+	if err := os.WriteFile(configFile, []byte(contents), 0o600); err != nil {
+		return fmt.Errorf("unable to create config file %s: %w", configFile, err)
+	}
+	fmt.Fprintf(os.Stderr, "First run: created config file %s\n", configFile)
+	fmt.Fprintf(os.Stderr, "Generated admin password: %s\n", password)
+	fmt.Fprintf(os.Stderr, "Save this password, it will not be shown again. Login with username \"admin\".\n\n")
+	return nil
+}
+
 func promptPassword(prompt string) (string, error) {
 	fmt.Print(prompt)
 	password, err := readPassword()

docs/content/docs/Installation.md

@@ -92,7 +92,21 @@ Apps are not affected: app containers keep running through the restart. In-place
 
 ## Install On Windows
 
-To install the OpenRun application on Windows, run:
+To install OpenRun using [winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/), run:
+
+```powershell
+winget install OpenRunDev.OpenRun
+```
+
+Open a new terminal so `openrun` is on the PATH, then run:
+
+```powershell
+openrun server start
+```
+
+On the first server start, OpenRun creates its config file under `$HOME\openrun` (or `$env:OPENRUN_HOME` if set) and generates an admin password. Note down the password printed.
+
+Alternatively, install using the install script:
 
 ```powershell
 powershell -Command "irm https://openrun.dev/install.ps1 | iex"
@@ -115,12 +129,48 @@ sc.exe failure openrun reset= 86400 actions= restart/5000/restart/30000//
 sc.exe start openrun
 ```
 
-The paths from `$env:OPENRUN_HOME` are expanded when the service is created; re-create the service if the install location changes. The service runs as LocalSystem by default; for a network facing server, consider a less privileged account using `sc.exe config openrun obj= <account>`.
+The paths from `$env:OPENRUN_HOME` are expanded when the service is created; re-create the service if the install location changes. For winget installs, see [Winget Service Install](#winget-service-install) below. The service runs as LocalSystem by default; for a network facing server, consider a less privileged account using `sc.exe config openrun obj= <account>`.
 
 When started this way, OpenRun reports service status to Windows and handles service stop, shutdown and pre-shutdown requests as graceful server shutdowns.
 
 Open https://localhost:25223 to access the app listing UI.
 
+### Winget Service Install
+
+To run OpenRun as a Windows service on a machine where it was installed with winget, the recommended approach is a machine scoped install with the service registered against an explicit config file. From an elevated shell:
+
+```powershell
+winget install --scope machine OpenRunDev.OpenRun
+```
+
+Machine scope installs the binary under `Program Files\WinGet` instead of the installing user's profile, which is preferable for a service. Open a new elevated terminal so `openrun` is on the PATH, then create the config file with a generated admin password:
+
+```powershell
+New-Item -ItemType Directory -Force C:\ProgramData\openrun | Out-Null
+openrun password | Out-File -Encoding utf8 C:\ProgramData\openrun\openrun.toml
+```
+
+Note down the password printed. Then register and start the service:
+
+```powershell
+$OpenRunExe = (Get-Command openrun.exe).Source
+$OpenRunConfig = 'C:\ProgramData\openrun\openrun.toml'
+sc.exe create openrun start= auto DisplayName= "OpenRun" binPath= "`"$OpenRunExe`" --config-file `"$OpenRunConfig`" server start"
+sc.exe description openrun "OpenRun application server https://openrun.dev/"
+sc.exe failure openrun reset= 86400 actions= restart/5000/restart/30000//
+sc.exe start openrun
+```
+
+Passing `--config-file` pins the server home directory to the config file's directory (`C:\ProgramData\openrun` here), keeping the service independent of any user profile. Without it, a service would resolve its home under the service account profile (for LocalSystem, `C:\Windows\System32\config\systemprofile`), and OpenRun refuses to auto-create a config there. To use the `openrun` CLI against this server from a regular shell, set the env variable at machine scope so the CLI resolves the same home:
+
+```powershell
+[Environment]::SetEnvironmentVariable('OPENRUN_HOME', 'C:\ProgramData\openrun', 'Machine')
+```
+
+For a default user scoped winget install, keep everything under the user profile instead: run `openrun server start` once interactively to create `$HOME\openrun\openrun.toml` (note down the generated admin password), stop it with Ctrl+C, then register the service with `$OpenRunConfig = Join-Path $HOME 'openrun\openrun.toml'` in the `sc.exe create` command above. No env variable is needed in this setup: the CLI defaults to the same `$HOME\openrun` home.
+
+In both flows, `(Get-Command openrun.exe).Source` resolves to the winget links shim, which stays valid across `winget upgrade`; after an upgrade, run `sc.exe stop openrun` and `sc.exe start openrun` to switch to the new binary.
+
 ## Brew Install
 
 To install using [brew](https://brew.sh/), run

docs/content/docs/QuickStart.md

@@ -32,11 +32,17 @@ brew services start openrun
 
 To install on Windows, run
 
+```
+winget install OpenRunDev.OpenRun
+```
+
+or use the install script:
+
 ```
 powershell -Command "irm https://openrun.dev/install.ps1 | iex"
 ```
 
-Start a new command window (to get the updated env) and run `openrun server start` to start the OpenRun service.
+Start a new command window (to get the updated env) and run `openrun server start` to start the OpenRun service. On the first start, OpenRun generates an admin password and prints it; note it down.
 
 ### Install Apps