322 lines
9.8 KiB
PowerShell
322 lines
9.8 KiB
PowerShell
<#
|
|
.SYNOPSIS
|
|
HTTP auto-update launcher for CMBot (docs/10-lan-update.md, stage 3).
|
|
|
|
.DESCRIPTION
|
|
Run instead of launching CMBot.exe directly. On each start it:
|
|
1. reads the local version from app\version.txt;
|
|
2. reads update_source/update_user/update_pass from data\config\app_config.json;
|
|
3. downloads manifest.json and, when newer, downloads the release zip;
|
|
4. verifies SHA-256, extracts to staging\app.new, and switches app/app.old;
|
|
5. launches app\CMBot.exe with CMBOT_DATA_DIR pointed at data\.
|
|
|
|
Degrades safely for normal updates: network errors, malformed manifests,
|
|
failed downloads, bad hashes, or bad zips leave the existing app\ version
|
|
in place and launch it.
|
|
|
|
.PARAMETER InstallRoot
|
|
Install directory holding Launcher.exe, app\, app.old\, data\, staging\.
|
|
Defaults to the launcher's own folder.
|
|
|
|
.PARAMETER NoLaunch
|
|
Do everything except start the app. For testing the update flow.
|
|
#>
|
|
[CmdletBinding()]
|
|
param(
|
|
[string]$InstallRoot = $PSScriptRoot,
|
|
[switch]$NoLaunch
|
|
)
|
|
|
|
$ErrorActionPreference = "Stop"
|
|
|
|
$AppExe = "CMBot.exe"
|
|
$ManifestName = "manifest.json"
|
|
$VersionFileName = "version.txt"
|
|
|
|
$AppDir = Join-Path $InstallRoot "app"
|
|
$OldAppDir = Join-Path $InstallRoot "app.old"
|
|
$DataDir = Join-Path $InstallRoot "data"
|
|
$StagingDir = Join-Path $InstallRoot "staging"
|
|
$ConfigFile = Join-Path $DataDir "config\app_config.json"
|
|
$LogFile = Join-Path $InstallRoot "launcher.log"
|
|
|
|
function Write-Log {
|
|
param([string]$Message)
|
|
$line = "{0} {1}" -f (Get-Date -Format "yyyy-MM-dd HH:mm:ss"), $Message
|
|
Write-Host $line
|
|
try { Add-Content -LiteralPath $LogFile -Value $line -Encoding UTF8 } catch { }
|
|
}
|
|
|
|
function Get-LocalVersion {
|
|
$versionFile = Join-Path $AppDir $VersionFileName
|
|
if (Test-Path -LiteralPath $versionFile) {
|
|
return (Get-Content -LiteralPath $versionFile -Raw).TrimStart([char]0xFEFF).Trim()
|
|
}
|
|
return ""
|
|
}
|
|
|
|
function Get-UpdateConfig {
|
|
$result = [ordered]@{
|
|
Source = ""
|
|
User = ""
|
|
Pass = ""
|
|
}
|
|
if (-not (Test-Path -LiteralPath $ConfigFile)) {
|
|
return $result
|
|
}
|
|
try {
|
|
$cfg = Get-Content -LiteralPath $ConfigFile -Raw | ConvertFrom-Json
|
|
$result.Source = [string]$cfg.update_source
|
|
$result.User = [string]$cfg.update_user
|
|
$result.Pass = [string]$cfg.update_pass
|
|
} catch {
|
|
Write-Log "Cannot read update config: $_"
|
|
}
|
|
return $result
|
|
}
|
|
|
|
function ConvertTo-VersionParts {
|
|
param([string]$Text)
|
|
$parts = @(0, 0, 0)
|
|
if ($Text) {
|
|
$chunks = $Text.Trim().Split(".")
|
|
for ($i = 0; $i -lt 3 -and $i -lt $chunks.Count; $i++) {
|
|
$digits = ($chunks[$i] -replace '^(\d*).*$', '$1')
|
|
if ($digits) { $parts[$i] = [int]$digits }
|
|
}
|
|
}
|
|
return ,$parts
|
|
}
|
|
|
|
function Test-IsNewer {
|
|
param([string]$Remote, [string]$Local)
|
|
$r = ConvertTo-VersionParts $Remote
|
|
$l = ConvertTo-VersionParts $Local
|
|
for ($i = 0; $i -lt 3; $i++) {
|
|
if ($r[$i] -gt $l[$i]) { return $true }
|
|
if ($r[$i] -lt $l[$i]) { return $false }
|
|
}
|
|
return $false
|
|
}
|
|
|
|
function Get-AuthHeaders {
|
|
param(
|
|
[string]$User,
|
|
[string]$Pass
|
|
)
|
|
$headers = @{}
|
|
if ($User -or $Pass) {
|
|
$bytes = [System.Text.Encoding]::UTF8.GetBytes(("{0}:{1}" -f $User, $Pass))
|
|
$headers["Authorization"] = "Basic " + [Convert]::ToBase64String($bytes)
|
|
}
|
|
return $headers
|
|
}
|
|
|
|
function Resolve-ManifestUrl {
|
|
param([string]$Source)
|
|
$uri = [System.Uri]$Source
|
|
if ([System.IO.Path]::GetFileName($uri.AbsolutePath).ToLowerInvariant() -eq $ManifestName) {
|
|
return $uri.AbsoluteUri
|
|
}
|
|
if (-not $Source.EndsWith("/")) {
|
|
$Source = "$Source/"
|
|
$uri = [System.Uri]$Source
|
|
}
|
|
return (New-Object -TypeName System.Uri -ArgumentList $uri, $ManifestName).AbsoluteUri
|
|
}
|
|
|
|
function Resolve-ReleaseUrl {
|
|
param(
|
|
[string]$ManifestUrl,
|
|
[string]$ReleaseUrl
|
|
)
|
|
$uri = $null
|
|
if ([System.Uri]::TryCreate($ReleaseUrl, [System.UriKind]::Absolute, [ref]$uri)) {
|
|
return $uri.AbsoluteUri
|
|
}
|
|
return (New-Object -TypeName System.Uri -ArgumentList ([System.Uri]$ManifestUrl), $ReleaseUrl).AbsoluteUri
|
|
}
|
|
|
|
function Invoke-JsonGet {
|
|
param(
|
|
[string]$Url,
|
|
[hashtable]$Headers
|
|
)
|
|
$response = Invoke-WebRequest -Uri $Url -Headers $Headers -UseBasicParsing -TimeoutSec 15
|
|
return $response.Content | ConvertFrom-Json
|
|
}
|
|
|
|
function Save-HttpFile {
|
|
param(
|
|
[string]$Url,
|
|
[string]$Destination,
|
|
[hashtable]$Headers
|
|
)
|
|
Invoke-WebRequest -Uri $Url -Headers $Headers -UseBasicParsing -TimeoutSec 120 -OutFile $Destination
|
|
}
|
|
|
|
function Remove-PathIfExists {
|
|
param([string]$Path)
|
|
if (Test-Path -LiteralPath $Path) {
|
|
Remove-Item -LiteralPath $Path -Recurse -Force
|
|
}
|
|
}
|
|
|
|
function Get-PackageRoot {
|
|
param([string]$ExtractDir)
|
|
if (Test-Path -LiteralPath (Join-Path $ExtractDir $AppExe)) {
|
|
return $ExtractDir
|
|
}
|
|
$children = @(Get-ChildItem -LiteralPath $ExtractDir -Directory)
|
|
if ($children.Count -eq 1) {
|
|
$candidate = $children[0].FullName
|
|
if (Test-Path -LiteralPath (Join-Path $candidate $AppExe)) {
|
|
return $candidate
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
function Assert-PackageValid {
|
|
param(
|
|
[string]$PackageRoot,
|
|
[string]$ExpectedVersion
|
|
)
|
|
if (-not $PackageRoot -or -not (Test-Path -LiteralPath (Join-Path $PackageRoot $AppExe))) {
|
|
throw "downloaded package does not contain $AppExe"
|
|
}
|
|
$versionFile = Join-Path $PackageRoot $VersionFileName
|
|
if (-not (Test-Path -LiteralPath $versionFile)) {
|
|
throw "downloaded package does not contain $VersionFileName"
|
|
}
|
|
$actualVersion = (Get-Content -LiteralPath $versionFile -Raw).TrimStart([char]0xFEFF).Trim()
|
|
if ($actualVersion -ne $ExpectedVersion) {
|
|
throw "package version '$actualVersion' does not match manifest '$ExpectedVersion'"
|
|
}
|
|
}
|
|
|
|
function Test-AppRunning {
|
|
$name = [System.IO.Path]::GetFileNameWithoutExtension($AppExe)
|
|
$exePath = Join-Path $AppDir $AppExe
|
|
$running = Get-Process -Name $name -ErrorAction SilentlyContinue | Where-Object {
|
|
try { $_.Path -eq $exePath } catch { $false }
|
|
}
|
|
return [bool]$running
|
|
}
|
|
|
|
function Switch-AppDirectory {
|
|
param([string]$PackageRoot)
|
|
if (Test-AppRunning) {
|
|
throw "$AppExe is already running"
|
|
}
|
|
if (Test-Path -LiteralPath $OldAppDir) {
|
|
Remove-Item -LiteralPath $OldAppDir -Recurse -Force
|
|
}
|
|
if (Test-Path -LiteralPath $AppDir) {
|
|
Move-Item -LiteralPath $AppDir -Destination $OldAppDir
|
|
}
|
|
try {
|
|
Move-Item -LiteralPath $PackageRoot -Destination $AppDir
|
|
} catch {
|
|
if ((-not (Test-Path -LiteralPath $AppDir)) -and (Test-Path -LiteralPath $OldAppDir)) {
|
|
Move-Item -LiteralPath $OldAppDir -Destination $AppDir
|
|
}
|
|
throw
|
|
}
|
|
}
|
|
|
|
function Invoke-Update {
|
|
param(
|
|
[string]$Source,
|
|
[string]$User,
|
|
[string]$Pass,
|
|
[string]$LocalVersion
|
|
)
|
|
|
|
$manifestUrl = Resolve-ManifestUrl $Source
|
|
$headers = Get-AuthHeaders -User $User -Pass $Pass
|
|
|
|
Write-Log "Checking update manifest: $manifestUrl"
|
|
$m = Invoke-JsonGet -Url $manifestUrl -Headers $headers
|
|
|
|
$remoteVer = [string]$m.version
|
|
if (-not $remoteVer) {
|
|
Write-Log "Manifest has no version - skip update."
|
|
return
|
|
}
|
|
if (-not (Test-IsNewer $remoteVer $LocalVersion)) {
|
|
Write-Log "Up to date (local '$LocalVersion', remote '$remoteVer')."
|
|
return
|
|
}
|
|
|
|
$releaseField = [string]$m.url
|
|
$expectedHash = ([string]$m.sha256).Trim().ToLowerInvariant()
|
|
if (-not $releaseField -or -not $expectedHash) {
|
|
throw "manifest must contain url and sha256"
|
|
}
|
|
$releaseUrl = Resolve-ReleaseUrl -ManifestUrl $manifestUrl -ReleaseUrl $releaseField
|
|
|
|
$zipPath = Join-Path $StagingDir ("{0}.zip" -f $remoteVer)
|
|
$extractDir = Join-Path $StagingDir "app.new"
|
|
Remove-PathIfExists -Path $zipPath
|
|
Remove-PathIfExists -Path $extractDir
|
|
|
|
Write-Log "Downloading v$remoteVer from $releaseUrl ..."
|
|
Save-HttpFile -Url $releaseUrl -Destination $zipPath -Headers $headers
|
|
|
|
if ($m.size) {
|
|
$actualSize = (Get-Item -LiteralPath $zipPath).Length
|
|
if ($actualSize -ne [int64]$m.size) {
|
|
throw "download size mismatch: got $actualSize, expected $($m.size)"
|
|
}
|
|
}
|
|
|
|
$actualHash = (Get-FileHash -LiteralPath $zipPath -Algorithm SHA256).Hash.ToLowerInvariant()
|
|
if ($actualHash -ne $expectedHash) {
|
|
throw "sha256 mismatch"
|
|
}
|
|
|
|
Expand-Archive -LiteralPath $zipPath -DestinationPath $extractDir -Force
|
|
$packageRoot = Get-PackageRoot -ExtractDir $extractDir
|
|
Assert-PackageValid -PackageRoot $packageRoot -ExpectedVersion $remoteVer
|
|
|
|
Switch-AppDirectory -PackageRoot $packageRoot
|
|
Remove-PathIfExists -Path $zipPath
|
|
Remove-PathIfExists -Path $extractDir
|
|
Write-Log "Installed and switched to v$remoteVer."
|
|
}
|
|
|
|
# -- main --------------------------------------------------------------------
|
|
|
|
New-Item -ItemType Directory -Force -Path $StagingDir | Out-Null
|
|
New-Item -ItemType Directory -Force -Path $DataDir | Out-Null
|
|
|
|
$local = Get-LocalVersion
|
|
$cfg = Get-UpdateConfig
|
|
|
|
if ($cfg.Source) {
|
|
try {
|
|
Invoke-Update -Source $cfg.Source -User $cfg.User -Pass $cfg.Pass -LocalVersion $local
|
|
} catch {
|
|
Write-Log "Update skipped (degraded to local version): $_"
|
|
}
|
|
} else {
|
|
Write-Log "No update_source configured - skip update check."
|
|
}
|
|
|
|
$current = Get-LocalVersion
|
|
$exe = Join-Path $AppDir $AppExe
|
|
if (-not (Test-Path -LiteralPath $exe)) {
|
|
Write-Log "ERROR: executable not found: $exe"
|
|
exit 1
|
|
}
|
|
|
|
if ($NoLaunch) {
|
|
Write-Log "NoLaunch: would start $exe v$current (CMBOT_DATA_DIR=$DataDir)"
|
|
exit 0
|
|
}
|
|
|
|
Write-Log "Launching v$current ..."
|
|
$env:CMBOT_DATA_DIR = $DataDir
|
|
Start-Process -FilePath $exe
|