install.ps1

# Vix.cpp installer for Windows PowerShell
# Usage:
# irm https://vixcpp.com/install.ps1 | iex
#
# Optional:
# $env:VIX_VERSION="vX.Y.Z"
# $env:VIX_REPO="vixcpp/vix"
# $env:VIX_STABLE_URL="https://vixcpp.com/releases/stable.txt"
# $env:VIX_INSTALL_DIR="$env:LOCALAPPDATA\Vix\bin"
# $env:VIX_INSTALL_SHARE_DIR="$env:LOCALAPPDATA\Vix\share"

$ErrorActionPreference = "Stop"
$ProgressPreference = "SilentlyContinue"

# Ensure GitHub and vixcpp.com work on Windows PowerShell 5.1.
try {
 [Net.ServicePointManager]::SecurityProtocol =
 [Net.ServicePointManager]::SecurityProtocol -bor
 [Net.SecurityProtocolType]::Tls12
} catch {
 # PowerShell editions using HttpClient do not require this setting.
}

$MinisignPubkey = "RWSIfpPSznK9A1gWUc8Eg2iXXQwU5d9BYuQNKGOcoujAF2stPu5rKFjQ"
$RequestHeaders = @{ "User-Agent" = "vix-installer" }

function Step([string]$Message) {
 Write-Host " → $Message"
}

function Ok([string]$Message) {
 Write-Host " ✓ $Message" -ForegroundColor Green
}

function Warn([string]$Message) {
 Write-Host " ! $Message" -ForegroundColor Yellow
}

function Hint([string]$Message) {
 Write-Host " · $Message" -ForegroundColor DarkGray
}

function Die([string]$Message) {
 Write-Host " ✗ $Message" -ForegroundColor Red
 exit 1
}

function Show-Help {
 Write-Host @"
Vix.cpp installer

Usage:
 install.ps1

Environment:
 VIX_VERSION
 Release version to install.

 Examples:
 latest
 vX.Y.Z

 Default: latest

 "latest" means the latest release validated by the complete
 Vix release CI, not necessarily the newest GitHub tag.

 VIX_STABLE_URL
 URL containing the latest validated release tag.

 Default:
 https://vixcpp.com/releases/stable.txt

 VIX_REPO
 GitHub repository containing release assets.

 Default:
 vixcpp/vix

 VIX_INSTALL_DIR
 CLI installation directory.

 Default:
 %LOCALAPPDATA%\Vix\bin

 VIX_INSTALL_SHARE_DIR
 Runtime assets installation directory.

 Default:
 %LOCALAPPDATA%\Vix\share

After installation:
 vix upgrade
 vix upgrade --check
 vix upgrade --sdk list
 vix upgrade --sdk web
"@
}

foreach ($arg in $args) {
 switch ($arg) {
 "--help" {
 Show-Help
 exit 0
 }

 "-h" {
 Show-Help
 exit 0
 }

 "--cli-only" {
 # Kept for backward compatibility.
 }

 "--cli" {
 # Kept for backward compatibility.
 }

 "--sdk" {
 Die "SDK installation moved to: vix upgrade --sdk"
 }

 default {
 Die "unknown option: $arg"
 }
 }
}

$Repo = if ($env:VIX_REPO) {
 $env:VIX_REPO
} else {
 "vixcpp/vix"
}

$Version = if ($env:VIX_VERSION) {
 $env:VIX_VERSION
} else {
 "latest"
}

$StableUrl = if ($env:VIX_STABLE_URL) {
 $env:VIX_STABLE_URL
} else {
 "https://vixcpp.com/releases/stable.txt"
}

$BinDir = if ($env:VIX_INSTALL_DIR) {
 $env:VIX_INSTALL_DIR
} else {
 Join-Path $env:LOCALAPPDATA "Vix\bin"
}

$ShareDir = if ($env:VIX_INSTALL_SHARE_DIR) {
 $env:VIX_INSTALL_SHARE_DIR
} else {
 $installRoot = Split-Path -Parent $BinDir
 Join-Path $installRoot "share"
}

$BinName = "vix.exe"

function Test-ReleaseTag([string]$Tag) {
 if ([string]::IsNullOrWhiteSpace($Tag)) {
 return $false
 }

 return $Tag -match '^v[0-9]+\.[0-9]+\.[0-9]+$'
}

function Get-NativeArchitectureName {
 if ($env:PROCESSOR_ARCHITEW6432) {
 return $env:PROCESSOR_ARCHITEW6432
 }

 return $env:PROCESSOR_ARCHITECTURE
}

function Detect-Architecture {
 $archRaw = Get-NativeArchitectureName

 switch -Regex ($archRaw) {
 "^AMD64$" {
 return "x86_64"
 }

 "^ARM64$" {
 Die "Windows ARM64 is not supported by this Vix release channel."
 }

 default {
 Die "unsupported architecture: $archRaw"
 }
 }
}

function Resolve-StableTag {
 try {
 $response = Invoke-WebRequest `
 -Uri $StableUrl `
 -Headers $RequestHeaders `
 -UseBasicParsing

 $lines = ([string]$response.Content) -split '\r?\n'

 $tag = $lines |
 ForEach-Object { $_.Trim() } |
 Where-Object { $_ -ne "" } |
 Select-Object -First 1

 if (-not (Test-ReleaseTag $tag)) {
 return $null
 }

 return $tag
 } catch {
 return $null
 }
}

function Test-UrlExists([string]$Url) {
 try {
 Invoke-WebRequest `
 -Uri $Url `
 -Method Head `
 -MaximumRedirection 10 `
 -Headers $RequestHeaders `
 -UseBasicParsing |
 Out-Null

 return $true
 } catch {
 return $false
 }
}

function Test-ReleaseInstallable(
 [string]$Tag,
 [string]$Repository,
 [string]$AssetName
) {
 if (-not (Test-ReleaseTag $Tag)) {
 return $false
 }

 $baseUrl = "https://github.com/$Repository/releases/download/$Tag"

 if (-not (Test-UrlExists "$baseUrl/$AssetName")) {
 return $false
 }

 if (-not (Test-UrlExists "$baseUrl/$AssetName.sha256")) {
 return $false
 }

 return $true
}

function Resolve-Version(
 [string]$RequestedVersion,
 [string]$Repository,
 [string]$AssetName
) {
 if ($RequestedVersion -ne "latest") {
 if (-not (Test-ReleaseTag $RequestedVersion)) {
 Die "invalid release version: $RequestedVersion"
 }

 if (-not (Test-ReleaseInstallable $RequestedVersion $Repository $AssetName)) {
 Die "release $RequestedVersion is incomplete for windows/$Arch"
 }

 return $RequestedVersion
 }

 $stable = Resolve-StableTag

 if (-not $stable) {
 Die "Could not resolve the latest validated Vix release. Please try again later."
 }

 if (-not (Test-ReleaseInstallable $stable $Repository $AssetName)) {
 Die "Could not resolve the latest validated Vix release. Please try again later."
 }

 return $stable
}

function Verify-Checksum([string]$ArchivePath, [string]$ShaPath) {
 $first = (Get-Content -LiteralPath $ShaPath -TotalCount 1).Trim()

 if (-not $first) {
 Die "invalid sha256 file"
 }

 $expected = $null

 if ($first -match "^([0-9a-fA-F]{64})(?:\s+.*)?$") {
 $expected = $Matches[1]
 } elseif ($first -match "=\s*([0-9a-fA-F]{64})\s*$") {
 $expected = $Matches[1]
 }

 if (-not $expected) {
 Die "invalid sha256 format"
 }

 $actual = (Get-FileHash -Algorithm SHA256 -LiteralPath $ArchivePath).Hash

 if ($expected.ToLowerInvariant() -ne $actual.ToLowerInvariant()) {
 Die "sha256 mismatch"
 }
}

function Verify-Signature([string]$ArchivePath, [string]$SigPath) {
 $minisign = Get-Command minisign -ErrorAction SilentlyContinue

 if (-not $minisign) {
 Hint "minisign is not installed; signature verification skipped"
 return
 }

 & $minisign.Path `
 -Vm $ArchivePath `
 -x $SigPath `
 -P $MinisignPubkey `
 *> $null

 if ($LASTEXITCODE -ne 0) {
 Die "signature verification failed"
 }

 Ok "minisign verified"
}

function Download-And-Verify-Asset(
 [string]$BaseUrl,
 [string]$AssetName,
 [string]$TmpDir
) {
 $archivePath = Join-Path $TmpDir $AssetName
 $shaPath = Join-Path $TmpDir ($AssetName + ".sha256")
 $sigPath = Join-Path $TmpDir ($AssetName + ".minisig")

 $assetUrl = "$BaseUrl/$AssetName"
 $shaUrl = "$BaseUrl/$AssetName.sha256"
 $sigUrl = "$BaseUrl/$AssetName.minisig"

 Step "Downloading $AssetName"

 try {
 Invoke-WebRequest `
 -Uri $assetUrl `
 -OutFile $archivePath `
 -Headers $RequestHeaders `
 -UseBasicParsing |
 Out-Null
 } catch {
 Die "release asset not found: $AssetName"
 }

 try {
 Invoke-WebRequest `
 -Uri $shaUrl `
 -OutFile $shaPath `
 -Headers $RequestHeaders `
 -UseBasicParsing |
 Out-Null
 } catch {
 Die "checksum file not found: $AssetName.sha256"
 }

 Verify-Checksum $archivePath $shaPath
 Ok "sha256 verified"

 $signatureDownloaded = $false

 try {
 Invoke-WebRequest `
 -Uri $sigUrl `
 -OutFile $sigPath `
 -Headers $RequestHeaders `
 -UseBasicParsing |
 Out-Null

 $signatureDownloaded = $true
 } catch {
 $signatureDownloaded = $false
 }

 if ($signatureDownloaded) {
 Verify-Signature $archivePath $sigPath
 }

 return $archivePath
}

function Install-SqliteDll([string]$InstallBin, [string]$TmpDir) {
 $sqliteDll = Join-Path $InstallBin "sqlite3.dll"

 if (Test-Path -LiteralPath $sqliteDll -PathType Leaf) {
 return
 }

 $archRaw = Get-NativeArchitectureName

 switch -Regex ($archRaw) {
 "^AMD64$" {
 $sqliteAsset = "sqlite-dll-win-x64-3530200.zip"
 }

 "^ARM64$" {
 $sqliteAsset = "sqlite-dll-win-arm64-3530200.zip"
 }

 "^x86$" {
 $sqliteAsset = "sqlite-dll-win-x86-3530200.zip"
 }

 default {
 Hint "sqlite runtime skipped: unsupported architecture $archRaw"
 return
 }
 }

 $sqliteUrl = "https://www.sqlite.org/2026/$sqliteAsset"
 $sqliteDir = Join-Path $TmpDir "sqlite"
 $sqliteZip = Join-Path $sqliteDir $sqliteAsset

 New-Item -ItemType Directory -Force -Path $sqliteDir | Out-Null
 New-Item -ItemType Directory -Force -Path $InstallBin | Out-Null

 Step "Installing SQLite runtime"

 try {
 Invoke-WebRequest `
 -Uri $sqliteUrl `
 -OutFile $sqliteZip `
 -Headers $RequestHeaders `
 -UseBasicParsing |
 Out-Null
 } catch {
 Hint "sqlite runtime skipped"
 return
 }

 try {
 Expand-Archive `
 -LiteralPath $sqliteZip `
 -DestinationPath $sqliteDir `
 -Force
 } catch {
 Hint "sqlite runtime skipped"
 return
 }

 $dllCandidate = Get-ChildItem `
 -LiteralPath $sqliteDir `
 -Recurse `
 -File `
 -Filter "sqlite3.dll" |
 Select-Object -First 1

 if (-not $dllCandidate) {
 Hint "sqlite runtime skipped"
 return
 }

 Copy-Item `
 -LiteralPath $dllCandidate.FullName `
 -Destination $sqliteDll `
 -Force

 if (Test-Path -LiteralPath $sqliteDll -PathType Leaf) {
 Ok "sqlite3.dll installed"
 }
}

function Add-To-UserPath([string]$PathToAdd) {
 $userPath = [Environment]::GetEnvironmentVariable("Path", "User")

 if (-not $userPath) {
 $userPath = ""
 }

 $segments = @(
 $userPath -split ";" |
 ForEach-Object { $_.Trim() } |
 Where-Object { $_ -ne "" }
 )

 foreach ($segment in $segments) {
 if ([string]::Equals(
 $segment.TrimEnd("\"),
 $PathToAdd.TrimEnd("\"),
 [System.StringComparison]::OrdinalIgnoreCase
 )) {
 return $true
 }
 }

 $newPath = (@($segments) + $PathToAdd) -join ";"
 [Environment]::SetEnvironmentVariable("Path", $newPath, "User")

 return $false
}

function Install-Cli(
 [string]$ArchivePath,
 [string]$TmpDir
) {
 $extractDir = Join-Path $TmpDir "cli"

 New-Item -ItemType Directory -Force -Path $extractDir | Out-Null
 New-Item -ItemType Directory -Force -Path $BinDir | Out-Null
 New-Item -ItemType Directory -Force -Path $ShareDir | Out-Null

 Step "Extracting $Asset"

 try {
 Expand-Archive `
 -LiteralPath $ArchivePath `
 -DestinationPath $extractDir `
 -Force
 } catch {
 Die "failed to extract $Asset"
 }

 $exeCandidate = Get-ChildItem `
 -LiteralPath $extractDir `
 -Recurse `
 -File `
 -Filter $BinName |
 Select-Object -First 1

 if (-not $exeCandidate) {
 Die "CLI archive does not contain $BinName"
 }

 $noteSource = Join-Path $extractDir "share\vix\note"
 $noteDestination = Join-Path $ShareDir "vix\note"
 $noteParent = Split-Path -Parent $noteDestination

 $noteIndex = Join-Path $noteSource "index.html"
 $noteCss = Join-Path $noteSource "assets\note.css"
 $noteJs = Join-Path $noteSource "assets\note.js"

 if (-not (Test-Path -LiteralPath $noteIndex -PathType Leaf)) {
 Die "CLI archive does not contain Vix Note index.html"
 }

 if (-not (Test-Path -LiteralPath $noteCss -PathType Leaf)) {
 Die "CLI archive does not contain Vix Note note.css"
 }

 if (-not (Test-Path -LiteralPath $noteJs -PathType Leaf)) {
 Die "CLI archive does not contain Vix Note note.js"
 }

 $exe = Join-Path $BinDir $BinName

 Step "Installing to $exe"

 Copy-Item `
 -LiteralPath $exeCandidate.FullName `
 -Destination $exe `
 -Force

 Step "Installing Vix Note assets to $noteDestination"

 New-Item `
 -ItemType Directory `
 -Force `
 -Path $noteParent |
 Out-Null

 if (Test-Path -LiteralPath $noteDestination) {
 Remove-Item `
 -LiteralPath $noteDestination `
 -Recurse `
 -Force
 }

 Copy-Item `
 -LiteralPath $noteSource `
 -Destination $noteDestination `
 -Recurse `
 -Force

 $installedIndex = Join-Path $noteDestination "index.html"
 $installedCss = Join-Path $noteDestination "assets\note.css"
 $installedJs = Join-Path $noteDestination "assets\note.js"

 if (-not (Test-Path -LiteralPath $installedIndex -PathType Leaf)) {
 Die "failed to install Vix Note index.html"
 }

 if (-not (Test-Path -LiteralPath $installedCss -PathType Leaf)) {
 Die "failed to install Vix Note note.css"
 }

 if (-not (Test-Path -LiteralPath $installedJs -PathType Leaf)) {
 Die "failed to install Vix Note note.js"
 }

 Ok "Vix Note assets installed"

 return $exe
}

$Arch = Detect-Architecture
$Asset = "vix-windows-$Arch.zip"

$TmpDir = Join-Path `
 ([System.IO.Path]::GetTempPath()) `
 ("vix-" + [System.Guid]::NewGuid().ToString("N"))

New-Item -ItemType Directory -Force -Path $TmpDir | Out-Null

try {
 Write-Host " ▲ " -NoNewline
 Write-Host "Vix.cpp" -NoNewline -ForegroundColor Green
 Write-Host " installer"
 Write-Host " ------------------------------------"

 $Tag = Resolve-Version $Version $Repo $Asset
 $BaseUrl = "https://github.com/$Repo/releases/download/$Tag"

 Write-Host " version $Tag"
 Write-Host " platform windows/$Arch"
 Write-Host ""

 $ArchivePath = Download-And-Verify-Asset $BaseUrl $Asset $TmpDir
 $Exe = Install-Cli $ArchivePath $TmpDir

 Install-SqliteDll $BinDir $TmpDir

 $PathAlreadyReady = Add-To-UserPath $BinDir

 try {
 & $Exe --version *> $null

 if ($LASTEXITCODE -ne 0) {
 throw "vix --version returned exit code $LASTEXITCODE"
 }

 Ok "Done — vix $Tag installed"
 } catch {
 Die "installed, but 'vix --version' failed"
 }

 if ($PathAlreadyReady) {
 Hint "run: vix upgrade --check"
 Hint "sdk: vix upgrade --sdk list"
 } else {
 Hint "restart your terminal if 'vix' is not found"
 Hint "then run: vix upgrade --sdk list"
 }
}
finally {
 Remove-Item `
 -LiteralPath $TmpDir `
 -Recurse `
 -Force `
 -ErrorAction SilentlyContinue |
 Out-Null
}