User setup cannot be updated when running as admin user without UAC

[dmitrivMS]

Repro steps

1. Turn off UAC control in Windows, restart
2. Login to Windows as an administrator user
3. Install VS Code user setup
4. Open VS Code
5. Check for 'Check for Update" under Help

Actual result
Updates are not available.
You see notification that VS Code cannot be updated since it's a User install and it is running as admin.

Expected result
VS Code should detect whether UAC is enabled and if not, allow updating User install when running as admin.

[tzengshinfu]

By the way, this notification keeps appearing every time I open a new VSCode instance after the 1.115.0 update, which is a bit annoying.

[dmitrivMS]

I'll fix this, but also this scenario should just work for updates which is a different issue.

[dwknight70]

I'm in total agreement here - as a sys admin in a corporate environment where we have UAC disabled on most of the servers we support, this is a very annoying issue. I did put together a PowerShell script that checks for the current release through the github api and updates the user setup if it isn't current by downloading and running the new package, but it is annoying having to do that periodically just to check if the version is current.

[dwknight70]

BTW - in case anyone find this useful, adding this to your prompt function in one of your PowerShell profile scripts adds a background thread once a day to check if your user-install of vscode is up to date or not, and if not will popup a dialog letting you know and will run the installer to update it if you wish. If it find itself running inside VS Code, it instead will ask you to run the install outside of vscode (the reference to running Update-VSCode manually is to a script we have in the local environment).

    #region VS Code background update check
    # Check if it has been more than a day since the last VS Code
    # update check. If so, launch a background thread that queries the Microsoft API
    # for the latest stable version. Results are picked up on subsequent prompt calls.

    #if (-not $global:iPoshVSCodeUpdateCheckStarted)
    #{
    #    $global:iPoshVSCodeUpdateCheckStarted = $true
        try
        {
            $vsCodeCheckRegPath = 'HKCU:\Software\VSCodeUpdateCheck'
            if (-not (Test-Path $vsCodeCheckRegPath))
            {
                $null = New-Item -Path $vsCodeCheckRegPath -Force
            }
            $lastCheck = (Get-ItemProperty -Path $vsCodeCheckRegPath -ErrorAction Ignore).VSCodeUpdateCheckUTC
            $shouldCheck = $true
            if ($lastCheck)
            {
                try
                {
                    $lastCheckTime = [datetime]::Parse($lastCheck)
                    if (([datetime]::UtcNow - $lastCheckTime).TotalHours -lt 24) { $shouldCheck = $false }
                }
                catch { }
            }

            if ($shouldCheck)
            {
                # Record that we checked today, regardless of outcome
                Set-ItemProperty -Path $vsCodeCheckRegPath -Name VSCodeUpdateCheckUTC -Value ([datetime]::UtcNow.ToString('o')) -Force

                # Only proceed if VS Code user-install exists
                $vsCodeUserPath = "$env:LOCALAPPDATA\Programs\Microsoft VS Code\Code.exe"
                if (Test-Path $vsCodeUserPath)
                {
                    $currentVSCodeVersion = (Get-Item $vsCodeUserPath).VersionInfo.ProductVersion
                    $global:iPoshVSCodeUpdatePS = [powershell]::Create()
                    $global:iPoshVSCodeUpdatePS.AddScript({
                        param($CurrentVersion)
                        try
                        {
                            $releases = Invoke-RestMethod -Uri 'https://update.code.visualstudio.com/api/releases/stable' -UseBasicParsing -TimeoutSec 15
                            $latestVersion = $releases[0]
                            if ([Version]$latestVersion -gt [Version]$CurrentVersion)
                            {
                                return @{ UpdateAvailable = $true; LatestVersion = $latestVersion; CurrentVersion = $CurrentVersion }
                            }
                        }
                        catch { }
                        return @{ UpdateAvailable = $false }
                    }).AddArgument($currentVSCodeVersion) | Out-Null
                    $global:iPoshVSCodeUpdateAsync = $global:iPoshVSCodeUpdatePS.BeginInvoke()
                }
            }
        }
        catch { }
    #}

    # Poll for completion of the VS Code update background check
    if ($global:iPoshVSCodeUpdateAsync -and $global:iPoshVSCodeUpdateAsync.IsCompleted)
    {
        try
        {
            $result = $global:iPoshVSCodeUpdatePS.EndInvoke($global:iPoshVSCodeUpdateAsync)
            if ($result -and $result.UpdateAvailable)
            {
                Add-Type -AssemblyName System.Windows.Forms -ErrorAction SilentlyContinue
                $answer = [System.Windows.Forms.MessageBox]::Show(
                    "A newer version of Visual Studio Code is available.`n`nInstalled: $($result.CurrentVersion)`nAvailable: $($result.LatestVersion)`n`nWould you like to update now?",
                    'VS Code Update Available',
                    [System.Windows.Forms.MessageBoxButtons]::YesNo,
                    [System.Windows.Forms.MessageBoxIcon]::Information
                )
                if ($answer -eq [System.Windows.Forms.DialogResult]::Yes)
                {
                    # Detect if we are running inside a VS Code terminal - stopping
                    # Code.exe from here would kill this terminal and abort the update.
                    $insideVSCode = $null -ne $env:TERM_PROGRAM -and $env:TERM_PROGRAM -eq 'vscode'

                    if ($insideVSCode)
                    {
                        Write-Host ''
                        Write-Host 'Cannot update VS Code from inside a VS Code terminal (stopping VS Code would terminate this session).' -ForegroundColor Yellow
                        Write-Host "Run '" -ForegroundColor Yellow -NoNewline
                        Write-Host 'Update-VSCode.ps1' -ForegroundColor Green -NoNewline
                        Write-Host "' from a regular PowerShell console to update." -ForegroundColor Yellow
                        Write-Host ''
                    }
                    else
                    {
                        # Download and install in the foreground so the user sees progress
                        $tempInstaller = Join-Path $env:TEMP "VSCodeSetup-$($result.LatestVersion).exe"
                        Write-Host 'Downloading VS Code update...' -ForegroundColor Cyan
                        $ProgressPreference = 'SilentlyContinue'
                        try
                        {
                            Invoke-WebRequest -Uri 'https://update.code.visualstudio.com/latest/win32-x64-user/stable' -OutFile $tempInstaller -UseBasicParsing
                            $vsCodeProcs = Get-Process 'Code' -ErrorAction SilentlyContinue |
                                Where-Object { $_.MainModule.FileName -eq "$env:LOCALAPPDATA\Programs\Microsoft VS Code\Code.exe" }
                            if ($vsCodeProcs)
                            {
                                Write-Host 'Closing running VS Code processes...' -ForegroundColor Cyan
                                $vsCodeProcs | Stop-Process -Force
                            }
                            Write-Host 'Installing VS Code update...' -ForegroundColor Cyan

                            # If we are elevated and UAC is enabled, the user-mode installer
                            # must run non-elevated so it targets the correct per-user paths.
                            # When UAC is disabled the elevated token IS the only token, so
                            # de-elevation is neither possible nor necessary.
                            $isElevated = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
                            $uacEnabled = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System' -Name EnableLUA -ErrorAction SilentlyContinue).EnableLUA -eq 1

                            if ($isElevated -and $uacEnabled)
                            {
                                # Use explorer.exe to launch the installer as the interactive
                                # (non-elevated) user. Explorer always runs at medium integrity.
                                $installerArgs = '/SILENT /MERGETASKS=!runcode'
                                $cmdLine = "cmd.exe /c `"start /wait `"`" `"$tempInstaller`" $installerArgs`""
                                Start-Process -FilePath "$env:SystemRoot\explorer.exe" -ArgumentList $cmdLine
                                # explorer.exe returns immediately; wait for the installer to finish
                                Write-Host 'Waiting for VS Code installer (running non-elevated)...' -ForegroundColor Cyan
                                $deadline = [datetime]::UtcNow.AddMinutes(5)
                                while ([datetime]::UtcNow -lt $deadline)
                                {
                                    Start-Sleep -Milliseconds 500
                                    $installerProc = Get-Process -Name 'VSCodeSetup*' -ErrorAction SilentlyContinue
                                    if (-not $installerProc) { break }
                                }
                            }
                            else
                            {
                                # Non-elevated, or elevated with UAC disabled - run directly
                                Start-Process -FilePath $tempInstaller -ArgumentList '/SILENT /MERGETASKS=!runcode' -Wait
                            }

                            Write-Host "VS Code updated to $($result.LatestVersion)." -ForegroundColor Green
                        }
                        catch
                        {
                            Write-Host "Failed to download or install VS Code update: $_" -ForegroundColor Red
                        }
                        finally
                        {
                            if ((Test-Path $tempInstaller)) { Remove-Item $tempInstaller -Force -ErrorAction SilentlyContinue }
                        }
                    }
                }
            }
        }
        catch { }
        finally
        {
            # Clean up the background runspace
            $global:iPoshVSCodeUpdatePS.Dispose()
            Remove-Variable -Name iPoshVSCodeUpdatePS -Scope Global -Force -ErrorAction SilentlyContinue
            Remove-Variable -Name iPoshVSCodeUpdateAsync -Scope Global -Force -ErrorAction SilentlyContinue
        }
    }
    #endregion VS Code background update check