Spaces:
Running
Running
Download scripts/install-muse.ps1 from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 29.9 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/scripts/install-muse.ps1
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/scripts/install-muse.ps1
-
curl -L -o install-muse.ps1 https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/scripts/install-muse.ps1
29.9 kB
| [CmdletBinding()] | |
| param( | |
| [switch] $DryRun, | |
| [switch] $Help, | |
| [Parameter(ValueFromRemainingArguments = $true)] | |
| [object[]] $RemainingArgs = @() | |
| ) | |
| Set-StrictMode -Version Latest | |
| $ErrorActionPreference = "Stop" | |
| $ProgressPreference = "SilentlyContinue" | |
| $script:MuseStableChannelUrl = "https://api.meta.ai/muse-code/channels/muse-stable" | |
| $script:MuseOwner = "free-claude-code-muse-installer" | |
| $script:MuseOwnerSchemaVersion = 1 | |
| $script:MuseMinimumVersion = [version] "0.2.1" | |
| function Show-MuseInstallerUsage { | |
| @" | |
| Usage: install-muse.ps1 [options] | |
| Installs or updates FCC's managed native-Windows Muse Code executable. | |
| The managed command is placed in %LOCALAPPDATA%\Programs\Muse Code\bin. | |
| Options: | |
| -DryRun Print actions without downloading or changing state. | |
| -Help Show this help text. | |
| To remove only this managed Muse installation, run scripts/uninstall-muse.ps1. | |
| "@ | |
| } | |
| function Get-MuseArtifactKey { | |
| param([Parameter(Mandatory = $true)][string] $Architecture) | |
| switch ($Architecture.Trim().ToUpperInvariant()) { | |
| "AMD64" { return "x86_windows" } | |
| "X64" { return "x86_windows" } | |
| "X86_64" { return "x86_windows" } | |
| "ARM64" { return "aarch64_windows" } | |
| default { | |
| throw "Muse Code does not provide a supported Windows release for architecture '$Architecture'." | |
| } | |
| } | |
| } | |
| function Get-MuseNativeArchitecture { | |
| return [Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString() | |
| } | |
| function Test-MuseSafeReleaseUrl { | |
| param([Parameter(Mandatory = $true)][string] $Value) | |
| if ([string]::IsNullOrWhiteSpace($Value) -or $Value -match '[\x00-\x1F\x7F]') { | |
| return $false | |
| } | |
| $uri = $null | |
| if (-not [Uri]::TryCreate($Value, [UriKind]::Absolute, [ref] $uri)) { | |
| return $false | |
| } | |
| return ( | |
| $uri.Scheme -eq "https" -and | |
| $uri.DnsSafeHost -eq "lookaside.facebook.com" -and | |
| [string]::IsNullOrEmpty($uri.UserInfo) -and | |
| [string]::IsNullOrEmpty($uri.Fragment) -and | |
| ($uri.IsDefaultPort -or $uri.Port -eq 443) | |
| ) | |
| } | |
| function Assert-MuseStableChannel { | |
| param([Parameter(Mandatory = $true)] $Channel) | |
| if ((-not (Test-MuseObjectProperty -Object $Channel -Name "channel")) -or $Channel.channel -ne "muse-stable") { | |
| throw "Meta's Muse stable channel response did not identify the muse-stable channel." | |
| } | |
| if ((-not (Test-MuseObjectProperty -Object $Channel -Name "state")) -or $Channel.state -ne "public") { | |
| throw "Meta's Muse stable channel is not public." | |
| } | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $Channel -Name "version")) -or | |
| ([string] $Channel.version) -notmatch '^\d+\.\d+\.\d+-R\d+(?:\.\d+)?$' | |
| ) { | |
| throw "Meta's Muse stable channel returned an invalid release version." | |
| } | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $Channel -Name "manifest_url")) -or | |
| (-not (Test-MuseSafeReleaseUrl -Value ([string] $Channel.manifest_url))) | |
| ) { | |
| throw "Meta's Muse manifest URL must use HTTPS on lookaside.facebook.com." | |
| } | |
| } | |
| function Test-MusePositiveInteger { | |
| param($Value) | |
| $integerTypes = @( | |
| [byte], | |
| [sbyte], | |
| [int16], | |
| [uint16], | |
| [int32], | |
| [uint32], | |
| [int64], | |
| [uint64] | |
| ) | |
| foreach ($integerType in $integerTypes) { | |
| if ($Value -is $integerType) { | |
| return ([decimal] $Value) -gt 0 | |
| } | |
| } | |
| return $false | |
| } | |
| function Test-MuseObjectProperty { | |
| param( | |
| [Parameter(Mandatory = $true)] $Object, | |
| [Parameter(Mandatory = $true)][string] $Name | |
| ) | |
| return $null -ne $Object -and $Object.PSObject.Properties.Name -contains $Name | |
| } | |
| function Resolve-MuseArtifact { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $Architecture, | |
| [Parameter(Mandatory = $true)] $Channel, | |
| [Parameter(Mandatory = $true)] $Manifest | |
| ) | |
| $artifactKey = Get-MuseArtifactKey -Architecture $Architecture | |
| Assert-MuseStableChannel -Channel $Channel | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $Manifest -Name "version")) -or | |
| ([string] $Manifest.version) -ne ([string] $Channel.version) | |
| ) { | |
| throw "Meta's Muse release manifest version does not match the stable channel." | |
| } | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $Manifest -Name "checksum_algorithm")) -or | |
| ([string] $Manifest.checksum_algorithm) -cne "sha256" | |
| ) { | |
| throw "Meta's Muse release manifest must use sha256 checksums." | |
| } | |
| if (-not (Test-MuseObjectProperty -Object $Manifest -Name "artifacts")) { | |
| throw "Meta's Muse release manifest did not contain artifacts." | |
| } | |
| $artifactProperty = $Manifest.artifacts.PSObject.Properties[$artifactKey] | |
| if ($null -eq $artifactProperty) { | |
| throw "Meta's Muse release manifest did not contain the '$artifactKey' artifact." | |
| } | |
| $artifact = $artifactProperty.Value | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $artifact -Name "url")) -or | |
| (-not (Test-MuseSafeReleaseUrl -Value ([string] $artifact.url))) | |
| ) { | |
| throw "Meta's Muse artifact URL must use HTTPS on lookaside.facebook.com." | |
| } | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $artifact -Name "checksum")) -or | |
| ([string] $artifact.checksum) -cnotmatch '^[0-9a-f]{64}$' | |
| ) { | |
| throw "Meta's Muse artifact checksum must be a lowercase SHA-256 value." | |
| } | |
| if ( | |
| (-not (Test-MuseObjectProperty -Object $artifact -Name "size")) -or | |
| (-not (Test-MusePositiveInteger -Value $artifact.size)) | |
| ) { | |
| throw "Meta's Muse artifact size must be a positive integer." | |
| } | |
| return [pscustomobject] @{ | |
| ReleaseVersion = [string] $Channel.version | |
| ArtifactKey = $artifactKey | |
| Url = [string] $artifact.url | |
| Sha256 = [string] $artifact.checksum | |
| Size = [long] $artifact.size | |
| } | |
| } | |
| function Read-MuseOwnershipRecord { | |
| param([Parameter(Mandatory = $true)][string] $RecordPath) | |
| if (-not (Test-Path -LiteralPath $RecordPath -PathType Leaf)) { | |
| return $null | |
| } | |
| try { | |
| $record = Get-Content -LiteralPath $RecordPath -Raw | ConvertFrom-Json | |
| } | |
| catch { | |
| throw "The Muse ownership record is malformed; refusing to change the managed directory." | |
| } | |
| $expectedFields = @( | |
| "schema_version", | |
| "owner", | |
| "release_version", | |
| "artifact_key", | |
| "sha256", | |
| "size" | |
| ) | |
| $actualFields = @($record.PSObject.Properties.Name) | |
| if ( | |
| $actualFields.Count -ne $expectedFields.Count -or | |
| @($expectedFields | Where-Object { $_ -notin $actualFields }).Count -gt 0 -or | |
| $record.schema_version -ne $script:MuseOwnerSchemaVersion -or | |
| $record.owner -ne $script:MuseOwner -or | |
| ([string] $record.release_version) -notmatch '^\d+\.\d+\.\d+-R\d+(?:\.\d+)?$' -or | |
| $record.artifact_key -notin @("x86_windows", "aarch64_windows") -or | |
| ([string] $record.sha256) -cnotmatch '^[0-9a-f]{64}$' -or | |
| (-not (Test-MusePositiveInteger -Value $record.size)) | |
| ) { | |
| throw "The Muse ownership record is unsupported or foreign; refusing to change the managed directory." | |
| } | |
| return $record | |
| } | |
| function Get-MuseCanonicalPath { | |
| param([Parameter(Mandatory = $true)][AllowEmptyString()][string] $Path) | |
| if ([string]::IsNullOrWhiteSpace($Path)) { | |
| return $null | |
| } | |
| try { | |
| $fullPath = [IO.Path]::GetFullPath($Path.Trim()) | |
| $root = [IO.Path]::GetPathRoot($fullPath) | |
| while ( | |
| $fullPath.Length -gt $root.Length -and | |
| ($fullPath.EndsWith("\") -or $fullPath.EndsWith("/")) | |
| ) { | |
| $fullPath = $fullPath.Substring(0, $fullPath.Length - 1) | |
| } | |
| return $fullPath | |
| } | |
| catch { | |
| return $null | |
| } | |
| } | |
| function Test-MuseEquivalentPath { | |
| param( | |
| [string] $Left, | |
| [string] $Right | |
| ) | |
| $canonicalLeft = Get-MuseCanonicalPath -Path $Left | |
| $canonicalRight = Get-MuseCanonicalPath -Path $Right | |
| return ( | |
| $null -ne $canonicalLeft -and | |
| $null -ne $canonicalRight -and | |
| [string]::Equals( | |
| $canonicalLeft, | |
| $canonicalRight, | |
| [StringComparison]::OrdinalIgnoreCase | |
| ) | |
| ) | |
| } | |
| function Add-MusePathValue { | |
| param( | |
| [AllowEmptyString()][string] $PathValue, | |
| [Parameter(Mandatory = $true)][string] $ManagedBin | |
| ) | |
| $canonicalManagedBin = Get-MuseCanonicalPath -Path $ManagedBin | |
| if ($null -eq $canonicalManagedBin) { | |
| throw "The managed Muse bin directory is invalid." | |
| } | |
| if ([string]::IsNullOrEmpty($PathValue)) { | |
| return $canonicalManagedBin | |
| } | |
| $entries = @($PathValue -split [regex]::Escape([string] [IO.Path]::PathSeparator)) | |
| $unrelated = @( | |
| $entries | Where-Object { | |
| -not (Test-MuseEquivalentPath -Left ([string] $_) -Right $canonicalManagedBin) | |
| } | |
| ) | |
| return (@($canonicalManagedBin) + $unrelated) -join [IO.Path]::PathSeparator | |
| } | |
| function Remove-MusePathValue { | |
| param( | |
| [AllowEmptyString()][string] $PathValue, | |
| [Parameter(Mandatory = $true)][string] $ManagedBin | |
| ) | |
| if ([string]::IsNullOrEmpty($PathValue)) { | |
| return "" | |
| } | |
| $entries = @($PathValue -split [regex]::Escape([string] [IO.Path]::PathSeparator)) | |
| return @( | |
| $entries | Where-Object { | |
| -not (Test-MuseEquivalentPath -Left ([string] $_) -Right $ManagedBin) | |
| } | |
| ) -join [IO.Path]::PathSeparator | |
| } | |
| function Assert-MuseArtifactIntegrity { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $Path, | |
| [Parameter(Mandatory = $true)][long] $ExpectedSize, | |
| [Parameter(Mandatory = $true)][string] $ExpectedSha256 | |
| ) | |
| if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) { | |
| throw "The downloaded Muse artifact is missing." | |
| } | |
| $actualSize = (Get-Item -LiteralPath $Path).Length | |
| if ($actualSize -ne $ExpectedSize) { | |
| throw "The downloaded Muse artifact size did not match the release manifest." | |
| } | |
| $stream = [IO.File]::OpenRead($Path) | |
| $sha256 = [Security.Cryptography.SHA256]::Create() | |
| try { | |
| $hashBytes = $sha256.ComputeHash($stream) | |
| $actualSha256 = ([BitConverter]::ToString($hashBytes) -replace "-", "").ToLowerInvariant() | |
| } | |
| finally { | |
| $sha256.Dispose() | |
| $stream.Dispose() | |
| } | |
| if ($actualSha256 -cne $ExpectedSha256) { | |
| throw "The downloaded Muse artifact SHA-256 did not match the release manifest." | |
| } | |
| } | |
| function Get-MuseInstallPaths { | |
| if ([string]::IsNullOrWhiteSpace($env:LOCALAPPDATA)) { | |
| throw "LOCALAPPDATA is not set; cannot locate the managed Muse Code installation." | |
| } | |
| $root = Join-Path $env:LOCALAPPDATA "Programs\Muse Code" | |
| $bin = Join-Path $root "bin" | |
| return [pscustomobject] @{ | |
| Root = $root | |
| Bin = $bin | |
| Executable = Join-Path $bin "muse.exe" | |
| Record = Join-Path $root ".fcc-muse-install.json" | |
| } | |
| } | |
| function Get-MuseUserPathValue { | |
| return [Environment]::GetEnvironmentVariable("Path", "User") | |
| } | |
| function Set-MuseUserPathValue { | |
| param([AllowEmptyString()][string] $Value) | |
| [Environment]::SetEnvironmentVariable("Path", $Value, "User") | |
| } | |
| function Resolve-MuseExternalCommand { | |
| $originalPath = $env:Path | |
| $userPath = Get-MuseUserPathValue | |
| try { | |
| $combined = @( | |
| $originalPath, | |
| $userPath | |
| ) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | |
| $env:Path = $combined -join [IO.Path]::PathSeparator | |
| $commands = @(Get-Command "muse" -CommandType Application -ErrorAction SilentlyContinue) | |
| if ($commands.Count -eq 0) { | |
| return $null | |
| } | |
| return $commands[0] | |
| } | |
| finally { | |
| $env:Path = $originalPath | |
| } | |
| } | |
| function ConvertTo-MuseNativeArgument { | |
| param([AllowEmptyString()][string] $Argument) | |
| if ($Argument.Length -gt 0 -and $Argument -notmatch '[\s"]') { | |
| return $Argument | |
| } | |
| $builder = [Text.StringBuilder]::new() | |
| [void] $builder.Append('"') | |
| $backslashes = 0 | |
| foreach ($character in $Argument.ToCharArray()) { | |
| if ([int] $character -eq 92) { | |
| $backslashes += 1 | |
| continue | |
| } | |
| if ([int] $character -eq 34) { | |
| for ($index = 0; $index -lt (($backslashes * 2) + 1); $index += 1) { | |
| [void] $builder.Append([char] 92) | |
| } | |
| [void] $builder.Append($character) | |
| $backslashes = 0 | |
| continue | |
| } | |
| for ($index = 0; $index -lt $backslashes; $index += 1) { | |
| [void] $builder.Append([char] 92) | |
| } | |
| $backslashes = 0 | |
| [void] $builder.Append($character) | |
| } | |
| for ($index = 0; $index -lt ($backslashes * 2); $index += 1) { | |
| [void] $builder.Append([char] 92) | |
| } | |
| [void] $builder.Append('"') | |
| return $builder.ToString() | |
| } | |
| function Invoke-MuseNativeProcess { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $FilePath, | |
| [string[]] $Arguments = @(), | |
| [int] $TimeoutMilliseconds = 5000 | |
| ) | |
| $startInfo = [Diagnostics.ProcessStartInfo]::new() | |
| $startInfo.FileName = $FilePath | |
| $startInfo.Arguments = ($Arguments | ForEach-Object { | |
| ConvertTo-MuseNativeArgument -Argument ([string] $_) | |
| }) -join " " | |
| $startInfo.UseShellExecute = $false | |
| $startInfo.CreateNoWindow = $true | |
| $startInfo.RedirectStandardOutput = $true | |
| $startInfo.RedirectStandardError = $true | |
| $process = [Diagnostics.Process]::new() | |
| $process.StartInfo = $startInfo | |
| try { | |
| try { | |
| if (-not $process.Start()) { | |
| return [pscustomobject] @{ | |
| Started = $false | |
| TimedOut = $false | |
| ExitCode = $null | |
| Output = "" | |
| } | |
| } | |
| } | |
| catch { | |
| return [pscustomobject] @{ | |
| Started = $false | |
| TimedOut = $false | |
| ExitCode = $null | |
| Output = "" | |
| } | |
| } | |
| $stdoutTask = $process.StandardOutput.ReadToEndAsync() | |
| $stderrTask = $process.StandardError.ReadToEndAsync() | |
| if (-not $process.WaitForExit($TimeoutMilliseconds)) { | |
| try { | |
| $process.Kill() | |
| $process.WaitForExit() | |
| } | |
| catch { | |
| # The process may have exited between the timeout and the kill. | |
| } | |
| return [pscustomobject] @{ | |
| Started = $true | |
| TimedOut = $true | |
| ExitCode = $null | |
| Output = "" | |
| } | |
| } | |
| $process.WaitForExit() | |
| $stdout = $stdoutTask.GetAwaiter().GetResult() | |
| $stderr = $stderrTask.GetAwaiter().GetResult() | |
| return [pscustomobject] @{ | |
| Started = $true | |
| TimedOut = $false | |
| ExitCode = $process.ExitCode | |
| Output = (@($stdout, $stderr) | Where-Object { | |
| -not [string]::IsNullOrWhiteSpace($_) | |
| }) -join [Environment]::NewLine | |
| } | |
| } | |
| finally { | |
| $process.Dispose() | |
| } | |
| } | |
| function Get-MuseVersionProbe { | |
| param([Parameter(Mandatory = $true)][string] $Path) | |
| $result = Invoke-MuseNativeProcess -FilePath $Path -Arguments @("--version") | |
| if (-not $result.Started) { | |
| return [pscustomobject] @{ | |
| Compatible = $false | |
| Version = $null | |
| Reason = "could not be started" | |
| } | |
| } | |
| if ($result.TimedOut) { | |
| return [pscustomobject] @{ | |
| Compatible = $false | |
| Version = $null | |
| Reason = "timed out" | |
| } | |
| } | |
| if ($result.ExitCode -ne 0) { | |
| return [pscustomobject] @{ | |
| Compatible = $false | |
| Version = $null | |
| Reason = "returned exit code $($result.ExitCode)" | |
| } | |
| } | |
| if ($result.Output -notmatch '(?m)^\s*Muse Code\s+(?<version>\d+\.\d+\.\d+)(?:\s+\([^\r\n]+\))?\s*$') { | |
| return [pscustomobject] @{ | |
| Compatible = $false | |
| Version = $null | |
| Reason = "did not identify itself as Muse Code" | |
| } | |
| } | |
| $version = [version] $Matches["version"] | |
| if ($version -lt $script:MuseMinimumVersion) { | |
| return [pscustomobject] @{ | |
| Compatible = $false | |
| Version = $version | |
| Reason = "is older than Muse Code $($script:MuseMinimumVersion)" | |
| } | |
| } | |
| return [pscustomobject] @{ | |
| Compatible = $true | |
| Version = $version | |
| Reason = "" | |
| } | |
| } | |
| function Assert-CompatibleMuseBinary { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $Path, | |
| [Parameter(Mandatory = $true)][string] $Context | |
| ) | |
| $probe = Get-MuseVersionProbe -Path $Path | |
| if (-not $probe.Compatible) { | |
| throw "$Context at '$Path' $($probe.Reason)." | |
| } | |
| } | |
| function Get-MuseReleaseArtifact { | |
| param([Parameter(Mandatory = $true)][string] $Architecture) | |
| try { | |
| $channel = Invoke-RestMethod ` | |
| -Uri $script:MuseStableChannelUrl ` | |
| -Method Get ` | |
| -TimeoutSec 30 ` | |
| -ErrorAction Stop | |
| } | |
| catch { | |
| throw "Could not fetch Meta's public Muse stable channel." | |
| } | |
| Assert-MuseStableChannel -Channel $channel | |
| try { | |
| $manifest = Invoke-RestMethod ` | |
| -Uri ([string] $channel.manifest_url) ` | |
| -Method Get ` | |
| -TimeoutSec 30 ` | |
| -ErrorAction Stop | |
| } | |
| catch { | |
| throw "Could not fetch Meta's public Muse release manifest." | |
| } | |
| return Resolve-MuseArtifact ` | |
| -Architecture $Architecture ` | |
| -Channel $channel ` | |
| -Manifest $manifest | |
| } | |
| function Save-MuseArtifact { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $Url, | |
| [Parameter(Mandatory = $true)][string] $Destination | |
| ) | |
| Write-Host "+ Download Meta's Muse executable to a temporary file" | |
| try { | |
| Invoke-WebRequest ` | |
| -Uri $Url ` | |
| -OutFile $Destination ` | |
| -TimeoutSec 600 ` | |
| -UseBasicParsing ` | |
| -ErrorAction Stop | |
| } | |
| catch { | |
| throw "Could not download Meta's public Muse Windows executable." | |
| } | |
| } | |
| function New-MuseOwnershipRecord { | |
| param([Parameter(Mandatory = $true)] $Artifact) | |
| return [ordered] @{ | |
| schema_version = $script:MuseOwnerSchemaVersion | |
| owner = $script:MuseOwner | |
| release_version = $Artifact.ReleaseVersion | |
| artifact_key = $Artifact.ArtifactKey | |
| sha256 = $Artifact.Sha256 | |
| size = [long] $Artifact.Size | |
| } | |
| } | |
| function Write-MuseRecordContent { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $RecordPath, | |
| [Parameter(Mandatory = $true)][string] $Content | |
| ) | |
| $temporaryPath = "$RecordPath.$([guid]::NewGuid().ToString('N')).tmp" | |
| $backupPath = "$RecordPath.$([guid]::NewGuid().ToString('N')).backup" | |
| try { | |
| [IO.File]::WriteAllText( | |
| $temporaryPath, | |
| $Content, | |
| [Text.UTF8Encoding]::new($false) | |
| ) | |
| if (Test-Path -LiteralPath $RecordPath -PathType Leaf) { | |
| [IO.File]::Replace($temporaryPath, $RecordPath, $backupPath) | |
| Remove-Item -LiteralPath $backupPath -Force -ErrorAction SilentlyContinue | |
| } | |
| else { | |
| [IO.File]::Move($temporaryPath, $RecordPath) | |
| } | |
| } | |
| finally { | |
| Remove-Item -LiteralPath $temporaryPath -Force -ErrorAction SilentlyContinue | |
| Remove-Item -LiteralPath $backupPath -Force -ErrorAction SilentlyContinue | |
| } | |
| } | |
| function Write-MuseOwnershipRecord { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $RecordPath, | |
| [Parameter(Mandatory = $true)] $Artifact | |
| ) | |
| $content = New-MuseOwnershipRecord -Artifact $Artifact | ConvertTo-Json | |
| Write-MuseRecordContent -RecordPath $RecordPath -Content $content | |
| } | |
| function Restore-MuseOwnershipRecord { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $RecordPath, | |
| [AllowNull()][string] $PreviousContent | |
| ) | |
| if ($null -eq $PreviousContent) { | |
| Remove-Item -LiteralPath $RecordPath -Force -ErrorAction SilentlyContinue | |
| return | |
| } | |
| Write-MuseRecordContent -RecordPath $RecordPath -Content $PreviousContent | |
| } | |
| function Test-MuseRecordMatchesArtifact { | |
| param( | |
| [Parameter(Mandatory = $true)] $Record, | |
| [Parameter(Mandatory = $true)] $Artifact | |
| ) | |
| return ( | |
| $Record.release_version -eq $Artifact.ReleaseVersion -and | |
| $Record.artifact_key -eq $Artifact.ArtifactKey -and | |
| $Record.sha256 -ceq $Artifact.Sha256 -and | |
| [long] $Record.size -eq [long] $Artifact.Size | |
| ) | |
| } | |
| function Test-MuseManagedArtifactCurrent { | |
| param( | |
| [Parameter(Mandatory = $true)] $Paths, | |
| [Parameter(Mandatory = $true)] $Record, | |
| [Parameter(Mandatory = $true)] $Artifact | |
| ) | |
| if (-not (Test-MuseRecordMatchesArtifact -Record $Record -Artifact $Artifact)) { | |
| return $false | |
| } | |
| try { | |
| Assert-MuseArtifactIntegrity ` | |
| -Path $Paths.Executable ` | |
| -ExpectedSize $Artifact.Size ` | |
| -ExpectedSha256 $Artifact.Sha256 | |
| Assert-CompatibleMuseBinary ` | |
| -Path $Paths.Executable ` | |
| -Context "The managed Muse Code executable" | |
| return $true | |
| } | |
| catch { | |
| return $false | |
| } | |
| } | |
| function Publish-MuseExecutable { | |
| param( | |
| [Parameter(Mandatory = $true)][string] $CandidatePath, | |
| [Parameter(Mandatory = $true)][string] $ExecutablePath | |
| ) | |
| $bin = Split-Path -Parent $ExecutablePath | |
| $stagingPath = Join-Path $bin (".muse-" + [guid]::NewGuid().ToString("N") + ".staging.exe") | |
| $backupPath = Join-Path $bin (".muse-" + [guid]::NewGuid().ToString("N") + ".backup.exe") | |
| $replacementCompleted = $false | |
| $backupRestored = $false | |
| try { | |
| Copy-Item -LiteralPath $CandidatePath -Destination $stagingPath | |
| if (Test-Path -LiteralPath $ExecutablePath -PathType Leaf) { | |
| try { | |
| [IO.File]::Replace($stagingPath, $ExecutablePath, $backupPath) | |
| $replacementCompleted = $true | |
| } | |
| catch { | |
| $publicationError = $_ | |
| if (Test-Path -LiteralPath $backupPath -PathType Leaf) { | |
| try { | |
| Remove-Item -LiteralPath $ExecutablePath -Force -ErrorAction SilentlyContinue | |
| [IO.File]::Move($backupPath, $ExecutablePath) | |
| $backupRestored = $true | |
| } | |
| catch { | |
| throw "Muse Code update failed and the previous executable could not be restored. The backup remains at '$backupPath'." | |
| } | |
| } | |
| throw $publicationError | |
| } | |
| } | |
| else { | |
| [IO.File]::Move($stagingPath, $ExecutablePath) | |
| $replacementCompleted = $true | |
| } | |
| } | |
| finally { | |
| Remove-Item -LiteralPath $stagingPath -Force -ErrorAction SilentlyContinue | |
| if ($replacementCompleted -or $backupRestored) { | |
| Remove-Item -LiteralPath $backupPath -Force -ErrorAction SilentlyContinue | |
| } | |
| } | |
| } | |
| function Update-MusePath { | |
| param([Parameter(Mandatory = $true)][string] $ManagedBin) | |
| $currentUserPath = [string] (Get-MuseUserPathValue) | |
| $newUserPath = Add-MusePathValue ` | |
| -PathValue $currentUserPath ` | |
| -ManagedBin $ManagedBin | |
| if (-not [string]::Equals($currentUserPath, $newUserPath, [StringComparison]::Ordinal)) { | |
| Set-MuseUserPathValue -Value $newUserPath | |
| } | |
| $env:Path = Add-MusePathValue -PathValue ([string] $env:Path) -ManagedBin $ManagedBin | |
| } | |
| function Remove-EmptyMuseInstallDirectories { | |
| param([Parameter(Mandatory = $true)] $Paths) | |
| foreach ($directory in @($Paths.Bin, $Paths.Root)) { | |
| if ( | |
| (Test-Path -LiteralPath $directory -PathType Container) -and | |
| @(Get-ChildItem -LiteralPath $directory -Force).Count -eq 0 | |
| ) { | |
| Remove-Item -LiteralPath $directory -Force -ErrorAction SilentlyContinue | |
| } | |
| } | |
| } | |
| function Remove-MuseTemporaryRoot { | |
| param([Parameter(Mandatory = $true)][string] $Path) | |
| if (-not (Test-Path -LiteralPath $Path -PathType Container)) { | |
| return | |
| } | |
| $temporaryBase = [IO.Path]::GetFullPath([IO.Path]::GetTempPath()).TrimEnd("\", "/") | |
| $resolvedPath = [IO.Path]::GetFullPath($Path).TrimEnd("\", "/") | |
| $requiredPrefix = $temporaryBase + [IO.Path]::DirectorySeparatorChar | |
| $leafName = [IO.Path]::GetFileName($resolvedPath) | |
| if ( | |
| (-not $resolvedPath.StartsWith($requiredPrefix, [StringComparison]::OrdinalIgnoreCase)) -or | |
| (-not $leafName.StartsWith("fcc-muse-", [StringComparison]::Ordinal)) | |
| ) { | |
| throw "Refusing to remove an unexpected Muse temporary directory: $resolvedPath" | |
| } | |
| Remove-Item -LiteralPath $resolvedPath -Recurse -Force | |
| } | |
| function Invoke-MuseInstaller { | |
| $architecture = Get-MuseNativeArchitecture | |
| [void] (Get-MuseArtifactKey -Architecture $architecture) | |
| $paths = Get-MuseInstallPaths | |
| if ($DryRun) { | |
| Write-Host "Dry run: inspect existing Muse ownership and commands." | |
| Write-Host "+ GET $script:MuseStableChannelUrl" | |
| Write-Host "+ verify release metadata, exact artifact size, SHA-256, and Muse version" | |
| Write-Host "+ install to '$($paths.Executable)' and prepend '$($paths.Bin)' to the user PATH" | |
| Write-Host "Dry run complete. No changes were made." | |
| return | |
| } | |
| if ( | |
| (Test-Path -LiteralPath $paths.Root) -and | |
| (-not (Test-Path -LiteralPath $paths.Root -PathType Container)) | |
| ) { | |
| throw "The managed Muse Code install path exists but is not owned by FCC: '$($paths.Root)'. Move or remove it, then rerun the installer." | |
| } | |
| $record = Read-MuseOwnershipRecord -RecordPath $paths.Record | |
| if ($null -eq $record) { | |
| if ( | |
| (Test-Path -LiteralPath $paths.Root -PathType Container) -and | |
| @(Get-ChildItem -LiteralPath $paths.Root -Force).Count -gt 0 | |
| ) { | |
| throw "The managed Muse Code directory exists but is not owned by FCC: '$($paths.Root)'. Move or remove it, then rerun the installer." | |
| } | |
| $externalCommand = Resolve-MuseExternalCommand | |
| if ($null -ne $externalCommand) { | |
| $externalPath = [string] $externalCommand.Source | |
| $probe = Get-MuseVersionProbe -Path $externalPath | |
| if (-not $probe.Compatible) { | |
| throw "A conflicting 'muse' command at '$externalPath' $($probe.Reason). Update or remove that command, then rerun the installer." | |
| } | |
| Write-Host "Compatible Muse Code already found at '$externalPath'; leaving it unchanged." | |
| return | |
| } | |
| } | |
| $artifact = Get-MuseReleaseArtifact -Architecture $architecture | |
| if ( | |
| $null -ne $record -and | |
| (Test-MuseManagedArtifactCurrent -Paths $paths -Record $record -Artifact $artifact) | |
| ) { | |
| Update-MusePath -ManagedBin $paths.Bin | |
| Assert-CompatibleMuseBinary ` | |
| -Path $paths.Executable ` | |
| -Context "The managed Muse Code executable" | |
| Write-Host "Muse Code $($artifact.ReleaseVersion) is already current and verified." | |
| return | |
| } | |
| $temporaryRoot = Join-Path ([IO.Path]::GetTempPath()) ("fcc-muse-" + [guid]::NewGuid().ToString("N")) | |
| $candidatePath = Join-Path $temporaryRoot "muse.exe" | |
| try { | |
| New-Item -ItemType Directory -Path $temporaryRoot | Out-Null | |
| Save-MuseArtifact -Url $artifact.Url -Destination $candidatePath | |
| Assert-MuseArtifactIntegrity ` | |
| -Path $candidatePath ` | |
| -ExpectedSize $artifact.Size ` | |
| -ExpectedSha256 $artifact.Sha256 | |
| Assert-CompatibleMuseBinary ` | |
| -Path $candidatePath ` | |
| -Context "The downloaded Muse Code executable" | |
| New-Item -ItemType Directory -Path $paths.Bin -Force | Out-Null | |
| $previousRecordContent = if (Test-Path -LiteralPath $paths.Record -PathType Leaf) { | |
| [IO.File]::ReadAllText($paths.Record) | |
| } | |
| else { | |
| $null | |
| } | |
| $recordWritten = $false | |
| try { | |
| Write-MuseOwnershipRecord -RecordPath $paths.Record -Artifact $artifact | |
| $recordWritten = $true | |
| Publish-MuseExecutable ` | |
| -CandidatePath $candidatePath ` | |
| -ExecutablePath $paths.Executable | |
| } | |
| catch { | |
| $publicationError = $_ | |
| if ($recordWritten) { | |
| try { | |
| Restore-MuseOwnershipRecord ` | |
| -RecordPath $paths.Record ` | |
| -PreviousContent $previousRecordContent | |
| } | |
| catch { | |
| throw "Muse Code publication failed and the previous ownership record could not be restored." | |
| } | |
| } | |
| Remove-EmptyMuseInstallDirectories -Paths $paths | |
| throw $publicationError | |
| } | |
| Update-MusePath -ManagedBin $paths.Bin | |
| Assert-CompatibleMuseBinary ` | |
| -Path $paths.Executable ` | |
| -Context "The published Muse Code executable" | |
| } | |
| finally { | |
| Remove-MuseTemporaryRoot -Path $temporaryRoot | |
| } | |
| Write-Host "Muse Code $($artifact.ReleaseVersion) was installed and verified at '$($paths.Executable)'." | |
| } | |
| if ($MyInvocation.InvocationName -ne ".") { | |
| if ($Help) { | |
| Show-MuseInstallerUsage | |
| return | |
| } | |
| if ($RemainingArgs.Count -gt 0) { | |
| Show-MuseInstallerUsage | |
| throw "Unknown option: $($RemainingArgs -join ' ')" | |
| } | |
| Invoke-MuseInstaller | |
| } | |