PowerShell script to automatically add context menu entries for Jetbrains IDEs

toolbox-context-menu.ps1

<#
.SYNOPSIS
    Automatically add context menu entries for Jetbrains IDEs.
.PARAMETER Name
    The name or names of the IDEs to add context menus for, use -List to see available IDEs.
.PARAMETER BasePath
    The path to the Toolbox apps directory, defaults to "$env:LOCALAPPDATA\JetBrains\Toolbox\apps".
.PARAMETER Global
    Install context menu entries in HKLM registry (machine wide), requires running as administrator.
.PARAMETER Force
    Overwrite current registry entries, useful when updating existing entries.
.PARAMETER Remove
    Will remove the context menu entries for specified IDEs
.PARAMETER List
    List available IDEs installed via Toolbox
.PARAMETER UseNircmd
    Will use nircmd (if installed) to invisibly run the IDE's batch script, this will avoid you having to
    re-run this script each time an IDE is updated via Toolbox.
.PARAMETER NirCmdPath
    Specify the location of the nircmd executable to use, will attempt to locate it from $PATH if not specified.
.PARAMETER AppDir
    If you are not using Toolbox you can specify the IDE's installation directory.
.PARAMETER DefaultChannel
    Specify the default channel to use when there are multiple channels found, the user will be prompted to
    choose a channel if the default channel is not found.
#>

[CmdletBinding()]
param (
    [array]$Name,
    [string]$BasePath,
    [switch]$Global,
    [switch]$Force,
    [switch]$Remove,
    [switch]$List,
    [switch]$UseNircmd,
    [string]$NirCmdPath,
    [string]$AppDir,
    [ArgumentCompleter({ return @("'Release'", "'Early Access Program'") })]
    [string]$DefaultChannel
)

$ErrorActionPreference = "Stop"
trap { throw $Error[0] }
$toolbox = if ($BasePath) { $BasePath } else { Join-Path $env:LOCALAPPDATA "JetBrains\Toolbox\apps" }
$regRoot = if ($Global) { "HKLM" } else { "HKCU" }

Write-Verbose "Toolbox: '$toolbox'"

if ($UseNircmd -and -not (Get-Command "nircmd.exe" -ErrorAction Ignore)) {
    Write-Error "nircmd.exe is not installed or missing from the path"
    Write-Error "either install nircmd or specify its location using '-NirCmdPath'"
    return
}

function Get-Channel([string]$Path) {
    $channels = Get-ChildItem (Join-Path $Path "ch-*")
    if (-not $channels) {
        Write-Warning "no channels found in '$Path'"
        return
    }
    # immediately return if only 1 channel
    if ($channels.Length -eq 1) {
        return $channels[0]
    }
    $channelsOutput = ""
    for ($i = 0; $i -lt $channels.Length; $i++) {
        $channel = $channels[$i]
        # extract channel type
        $channelSettings = (Get-Content (Join-Path $channel.FullName ".channel.settings.json") | ConvertFrom-Json)
        $channelName = $channelSettings.filter.quality_filter.name
        # skip the prompt if we match the default channel
        if ($DefaultChannel -eq $channelName) {
            return $channel
        }
        $channelsOutput += "[$i]: '$($channel.BaseName)' ($channelName)"
        if ($i -lt $channels.Length - 1) {
            $channelsOutput += "`n"
        }
    }
    # prompt user to select which channel to use
    Write-Host (Split-Path -Leaf $Path) -ForegroundColor Green
    Write-Host $channelsOutput
    $i = $null
    while (-not ($i -ge 0 -and $i -lt $channels.Length)) {
        if ($null -ne $i) {
            Write-Host "'$i' is not a valid index." -ForegroundColor Red
        }
        $i = Read-Host "Enter the number of the desired channel"
    }
    return $channels[$i]
}

function Get-IDEs {
    $IDEs = @{}
    foreach ($item in (Get-ChildItem $toolbox -Exclude Toolbox)) {
        $channel = Get-Channel -Path $item.FullName
        if (-not $channel) { continue }
        $versionPath = (Get-ChildItem -Path $channel -Directory -Exclude "*.plugins" | Sort-Object BaseName -Descending | Select-Object -First 1 | Select-Object -ExpandProperty FullName)
        Write-Verbose "Version Path: '$versionPath'"
        $binPath = Join-Path $versionPath "bin"
        if (Test-Path $binPath) {
            $IDEs[$item.BaseName] = $versionPath
        }
    }
    return $IDEs
}

if ($List) {
    return Get-IDEs
}

function Add-ShellKeys {
    param (
        [string]$Name,
        [string]$ExePath,
        [string]$Path,
        [string]$Action,
        [string]$LaunchArgs
    )

    $Path = Join-Path "${regRoot}:" $Path
    if ($UseNircmd) {
        # extract shell link path
        $scriptPath = Get-Content (Join-Path (Split-Path $ExePath) "../.." ".shellLink")

        # move icon outside of version directory so it will survive updates
        $baseName = (Split-Path $ExePath -LeafBase).Replace("64", "")
        $iconPath = Join-Path (Split-Path $ExePath) "$baseName.ico"
        $destPath = Join-Path (Split-Path (Split-Path (Split-Path $ExePath))) "$baseName.ico"
        Move-Item -Path $iconPath -Destination $destPath -ErrorAction Ignore
        $iconPath = "`"$destPath`",0"

        # contruct args
        $ExePath = if ($NirCmdPath) { $NirCmdPath } else { (Get-Command "nircmd.exe").Path }
        $LaunchArgs = "execmd $scriptPath $LaunchArgs"
    } else {
        $iconPath = $ExePath
    }

    if (-not $Force -and (Test-Path -LiteralPath "$Path\$Name")) {
        Write-Host "EXISTS: $Path\$Name" -f Yellow
    } else {
        New-Item `
            -Path "$Path\$Name" `
            -Value "$Action with $Name" `
            -Force:$Force `
            -Confirm:$false | Out-Null
        Write-Host "ADDED: $Path\$Name" -f DarkGreen
    }

    if (-not $Force -and (Get-ItemProperty -LiteralPath "$Path\$Name" -Name "Icon" -ErrorAction Ignore)) {
        Write-Host "EXISTS: $Path\$Name [Icon]" -f Yellow
    } else {
        New-ItemProperty `
            -LiteralPath "$Path\$Name" `
            -PropertyType ExpandString `
            -Name "Icon" `
            -Value $iconPath `
            -Force:$Force `
            -Confirm:$false | Out-Null
        Write-Host "ADDED: $Path\$Name [Icon]" -f DarkGreen
    }

    if (-not $Force -and (Get-Item -LiteralPath "$Path\$Name\command" -ErrorAction Ignore)) {
        Write-Host "EXISTS: $Path\$Name\command" -f Yellow
    } else {
        New-Item `
            -Path "$Path\$Name\command" `
            -Value "`"$exePath`" $LaunchArgs" `
            -Force:$Force `
            -Confirm:$false | Out-Null
        Write-Host "ADDED: $Path\$Name\command" -f DarkGreen
    }
}

function Add-RegKey([string]$Path) {
    $Path = Join-Path "${regRoot}:" $Path
    if (-not (Test-Path -LiteralPath $Path)) {
        New-Item -Path $Path -Force -ErrorAction Ignore -Confirm:$false | Out-Null
    }
}

function Add-ContextMenu {
    param (
        [string]$Name,
        [string]$ExePath
    )

    # ensure base folders exist
    Add-RegKey "SOFTWARE\Classes\`*\shell"
    Add-RegKey "SOFTWARE\Classes\Directory\shell"
    Add-RegKey "SOFTWARE\Classes\Directory\Background\shell"

    # add to file context menu
    Write-Output "ACTION: Edit with $Name (Files)"
    Add-ShellKeys $Name $ExePath "SOFTWARE\Classes\*\shell" "Edit" "`"%1`""

    # add to directory context menu
    Write-Output "ACTION: Open with $Name (Directory)"
    Add-ShellKeys $Name $ExePath "SOFTWARE\Classes\Directory\shell" "Open" "`"%1`""

    # add to directory background context menu
    Write-Output "ACTION: Open with $Name (Directory Background)"
    Add-ShellKeys $Name $ExePath "SOFTWARE\Classes\Directory\Background\shell" "Open" "`"%V`""
}

function Remove-Reg([string]$Path) {
    $Path = Join-Path "${regRoot}:" $Path
    if (-not (Test-Path -LiteralPath $Path)) {
        Write-Host "MISSING: $Path" -f Yellow
    } else {
        Remove-Item -LiteralPath $Path -Recurse
        Write-Host "REMOVED: $Path" -f Red
    }
}

function Remove-ContextMenu([string]$Name) {
    Remove-Reg "SOFTWARE\Classes\*\shell\$Name"
    Remove-Reg "SOFTWARE\Classes\Directory\shell\$Name"
    Remove-Reg "SOFTWARE\Classes\Directory\Background\shell\$Name"
}

function Start-ContextMenu([string]$AppDir) {
    $info = (Get-Content (Join-Path $AppDir "product-info.json") | ConvertFrom-Json)
    $friendlyName = $info.Name
    $exePath = Join-Path $AppDir $info.launch[0].launcherPath
    if ($Remove) {
        Write-Host "Removing Context Menu for '$friendlyName'" -ForegroundColor Cyan
        Remove-ContextMenu -Name $friendlyName
    } else {
        Write-Host "Adding Context Menu for '$friendlyName'" -ForegroundColor Cyan
        Add-ContextMenu -Name $friendlyName -ExePath $exePath
    }
}

if ($AppDir) {
    Start-ContextMenu $AppDir
} else {
    $ides = (Get-IDEs)

    foreach ($ide in $ides.Keys) {
        foreach ($match in $Name) {
            if (($match -eq "*") -or ($ide.ToLower().StartsWith($match.ToLower()))) {
                Start-ContextMenu $ides[$ide]
                break
            }
        }
    }
}

It's difficult to know due to how JetBrains enumerates.
For example:
If you have 5 versions installed, it may look something like this

ch-0
ch-1
ch-2
ch-3
ch-4

but if you uninstall 3 versions, you may end up with any combination of the remaining versions; In this case, any two versions.

ch-1
ch-3

now when a user installs a new version, it will be placed in ch-0:

ch-0
ch-1
ch-3

and another...

ch-0
ch-1
ch-2
ch-3

and for completeness sake, another version:

ch-0
ch-1
ch-2
ch-3
ch-4

this will be followed by ch-5, and so on.

The solution proposed won't fix all cases unfortunately.

You may want to look at grabbing the version number from each channel and selecting the largest, however it may be best from a UX standpoint to prompt the user for input in this scenario.

Righhht I totally understand what you mean now, thanks for that. Indeed automatically selecting it won't be a good option, I think prompting the user is a good way to go. I'll probably also add a flag like -DefaultChannel Release which can check .channel.settings.json to see if it's the release version and use that if found.

I've added the channel selection functionality, and also added the DefaultChannel parameter so you can set a default channel to use and skip the selection prompt if it's found. So, hopefully, it should now be working for everyone.

Very nice job! Very helpful. Appreciate your effort.

Hi @jcwillox, thank you for this utility. I have now reinstalled my JetBrains tools using the Jetbrains Toolbox and am using this utility to add the entries to the context menu via the default method.

However, when trying to add the context menu entries using the Nircmd method, I am receiving this error when running the command:

➜ .\toolbox-context-menu.ps1 rider -UseNircmd -Force
Adding Context Menu for 'JetBrains Rider'
ACTION: Edit with JetBrains Rider (Files)
Join-Path : A positional parameter cannot be found that accepts argument '.shellLink'.
At C:\Users\Harry\AppData\Local\JetBrains\Toolbox\scripts\toolbox-context-menu.ps1:123 char:32
+ ...  = Get-Content (Join-Path (Split-Path $ExePath) "../.." ".shellLink")
+                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidArgument: (:) [Join-Path], ParameterBindingException
    + FullyQualifiedErrorId : PositionalParameterNotFound,Microsoft.PowerShell.Commands.JoinPathCommand

Any ideas how this can be resolved?

Cheers!

Thanks! Pretty sure you just need to enable "shell scripts" in toolbox's settings and provide toolbox a location to put the shell scripts.

Hey, just thought I would put an updated comment on. Used the default method today and worked like a charm, found the dirs and applications and added / removed them super easy. Cheers!

Forgot to update the instructions comment at the top for toolbox 2.0, but better late than never, you can just use the direct install method now.
https://gist.github.com/jcwillox/a9b480f8d180d44368e7df2eb7009207?permalink_comment_id=4037552#gistcomment-4037552

I think I need a little more context/guidance for this one. First, the installation instructions needed an explicit parameter in modern pwsh:

❌

iwr https://gist.github.com/jcwillox/a9b480f8d180d44368e7df2eb7009207/raw/toolbox-context-menu.ps1 -o toolbox-context-menu.ps1
Invoke-WebRequest: Parameter cannot be processed because the parameter name 'o' is ambiguous. Possible matches include: -OperationTimeoutSeconds -OutFile -OutVariable -OutBuffer.

👇

✅

iwr https://gist.github.com/jcwillox/a9b480f8d180d44368e7df2eb7009207/raw/toolbox-context-menu.ps1 -OutFile toolbox-context-menu.ps1

Now, how exactly do I use it?
No matter the parameters, I get an error:

pwsh> .\toolbox-context-menu.ps1 webstorm
WARNING: no channels found in 'C:\Users\josch\AppData\Local\JetBrains\Toolbox\apps\Datalore'
WARNING: no channels found in 'C:\Users\josch\AppData\Local\JetBrains\Toolbox\apps\JetBrainsGateway'
Exception: D:\projects\toolbox-context-menu.ps1:101
Line |
 101 |          $binPath = Join-Path $versionPath "bin"
     |                               ~~~~~~~~~~~~
     | Cannot bind argument to parameter 'Path' because it is null.

Yep thanks, the download command is broken in my terminal now too, pretty bad of them to break that in a minor update, but anyhow, I've updated the download command.

That comment provides the usage instructions too, and it looks like you're not running the correct command, for toolbox v2, you should use something like this

.\toolbox-context-menu.ps1 -AppDir "C:\Users\%USERNAME%\AppData\Local\Programs\PyCharm Professional"