558 lines
19 KiB
PowerShell
558 lines
19 KiB
PowerShell
[CmdletBinding()]
|
|
param(
|
|
[ValidateNotNullOrEmpty()]
|
|
[string]$InstallRoot = (Join-Path $env:LOCALAPPDATA 'MercuryToolbox'),
|
|
[string]$CodexHome,
|
|
[switch]$NoCodexSkillInstall,
|
|
[switch]$NoPathUpdate
|
|
)
|
|
|
|
$ErrorActionPreference = 'Stop'
|
|
Set-StrictMode -Version Latest
|
|
|
|
. (Join-Path $PSScriptRoot 'toolbox-commands.ps1')
|
|
|
|
function Normalize-PathValue {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$PathValue
|
|
)
|
|
|
|
if ([string]::IsNullOrWhiteSpace($PathValue)) {
|
|
return ''
|
|
}
|
|
|
|
return $PathValue.Replace('/', '\').Trim().TrimEnd('\').ToLowerInvariant()
|
|
}
|
|
|
|
function Split-PathEntries {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$PathValue
|
|
)
|
|
|
|
if ([string]::IsNullOrWhiteSpace($PathValue)) {
|
|
return @()
|
|
}
|
|
|
|
return $PathValue.Split(';', [System.StringSplitOptions]::RemoveEmptyEntries)
|
|
}
|
|
|
|
function Add-PathEntry {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$ExistingPath,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Entry
|
|
)
|
|
|
|
$normalizedEntry = Normalize-PathValue -PathValue $Entry
|
|
$entries = Split-PathEntries -PathValue $ExistingPath
|
|
foreach ($existing in $entries) {
|
|
if ((Normalize-PathValue -PathValue $existing) -eq $normalizedEntry) {
|
|
return @{
|
|
Changed = $false
|
|
Value = $ExistingPath
|
|
}
|
|
}
|
|
}
|
|
|
|
$newEntries = @($entries + $Entry)
|
|
return @{
|
|
Changed = $true
|
|
Value = ($newEntries -join ';')
|
|
}
|
|
}
|
|
|
|
function Remove-PathEntry {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$ExistingPath,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Entry
|
|
)
|
|
|
|
$normalizedEntry = Normalize-PathValue -PathValue $Entry
|
|
$remaining = [System.Collections.Generic.List[string]]::new()
|
|
$changed = $false
|
|
|
|
foreach ($existing in (Split-PathEntries -PathValue $ExistingPath)) {
|
|
if ((Normalize-PathValue -PathValue $existing) -eq $normalizedEntry) {
|
|
$changed = $true
|
|
continue
|
|
}
|
|
$remaining.Add($existing)
|
|
}
|
|
|
|
return @{
|
|
Changed = $changed
|
|
Value = ($remaining -join ';')
|
|
}
|
|
}
|
|
|
|
function Copy-OptionalFile {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$SourcePath,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$DestinationPath
|
|
)
|
|
|
|
if (Test-Path -LiteralPath $SourcePath) {
|
|
$destinationDirectory = Split-Path -Parent $DestinationPath
|
|
if (-not [string]::IsNullOrWhiteSpace($destinationDirectory)) {
|
|
New-Item -ItemType Directory -Force -Path $destinationDirectory | Out-Null
|
|
}
|
|
Copy-Item -LiteralPath $SourcePath -Destination $DestinationPath -Force
|
|
}
|
|
}
|
|
|
|
function Assert-ExistingPathNotReparsePoint {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Path,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Description
|
|
)
|
|
|
|
$resolvedPath = [System.IO.Path]::GetFullPath($Path)
|
|
if (-not (Test-Path -LiteralPath $resolvedPath)) {
|
|
return
|
|
}
|
|
|
|
$item = Get-Item -LiteralPath $resolvedPath -Force
|
|
if (($item.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0) {
|
|
throw "$Description must not be a reparse point: $resolvedPath"
|
|
}
|
|
}
|
|
|
|
function Assert-ExistingTreeHasNoReparsePoints {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Path,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Description
|
|
)
|
|
|
|
$resolvedPath = [System.IO.Path]::GetFullPath($Path)
|
|
if (-not (Test-Path -LiteralPath $resolvedPath)) {
|
|
return
|
|
}
|
|
|
|
$reparsePoints = @(Get-ChildItem -LiteralPath $resolvedPath -Force -Recurse -Attributes ReparsePoint)
|
|
if ($reparsePoints.Count -gt 0) {
|
|
throw "$Description must not contain reparse points: $($reparsePoints[0].FullName)"
|
|
}
|
|
}
|
|
|
|
function Copy-DirectoryTree {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$SourcePath,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$DestinationPath
|
|
)
|
|
|
|
if (-not (Test-Path -LiteralPath $SourcePath)) {
|
|
throw "Required directory not found: $SourcePath"
|
|
}
|
|
|
|
$sourceRoot = Get-Item -LiteralPath $SourcePath -Force
|
|
if (($sourceRoot.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0) {
|
|
throw "Refusing to copy reparse-point directory: $SourcePath"
|
|
}
|
|
|
|
$reparsePoints = @(Get-ChildItem -LiteralPath $SourcePath -Force -Recurse -Attributes ReparsePoint)
|
|
if ($reparsePoints.Count -gt 0) {
|
|
throw "Refusing to copy directory tree containing reparse points: $($reparsePoints[0].FullName)"
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $DestinationPath) {
|
|
Remove-Item -LiteralPath $DestinationPath -Recurse -Force
|
|
}
|
|
|
|
$destinationParent = Split-Path -Parent $DestinationPath
|
|
if (-not [string]::IsNullOrWhiteSpace($destinationParent)) {
|
|
New-Item -ItemType Directory -Force -Path $destinationParent | Out-Null
|
|
}
|
|
|
|
Copy-Item -LiteralPath $SourcePath -Destination $DestinationPath -Recurse -Force
|
|
}
|
|
|
|
function Get-PathWithTrailingSeparator {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Path
|
|
)
|
|
|
|
$trimmed = $Path.TrimEnd([System.IO.Path]::DirectorySeparatorChar, [System.IO.Path]::AltDirectorySeparatorChar)
|
|
return $trimmed + [System.IO.Path]::DirectorySeparatorChar
|
|
}
|
|
|
|
function Assert-PackageSha256Sums {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$PackageRoot,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$HashPath
|
|
)
|
|
|
|
if (-not (Test-Path -LiteralPath $HashPath)) {
|
|
throw "Package checksum file not found: $HashPath"
|
|
}
|
|
|
|
$packageRootItem = Get-Item -LiteralPath $PackageRoot -Force
|
|
if (($packageRootItem.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0) {
|
|
throw "Package root must not be a reparse point: $PackageRoot"
|
|
}
|
|
|
|
$packageReparsePoints = @(Get-ChildItem -LiteralPath $PackageRoot -Force -Recurse -Attributes ReparsePoint)
|
|
if ($packageReparsePoints.Count -gt 0) {
|
|
throw "Package tree contains reparse points: $($packageReparsePoints[0].FullName)"
|
|
}
|
|
|
|
$resolvedPackageRoot = [System.IO.Path]::GetFullPath($PackageRoot)
|
|
$packageRootPrefix = Get-PathWithTrailingSeparator -Path $resolvedPackageRoot
|
|
$listedFiles = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
|
|
$lineNumber = 0
|
|
$entryCount = 0
|
|
foreach ($line in Get-Content -LiteralPath $HashPath) {
|
|
$lineNumber++
|
|
if ([string]::IsNullOrWhiteSpace($line)) {
|
|
continue
|
|
}
|
|
if ($line -notmatch '^(?<hash>[A-Fa-f0-9]{64})\s+\*?(?<path>.+)$') {
|
|
throw "Invalid checksum entry at ${HashPath}:$lineNumber"
|
|
}
|
|
|
|
$relativePath = $Matches.path.Trim()
|
|
if ([string]::IsNullOrWhiteSpace($relativePath) -or [System.IO.Path]::IsPathRooted($relativePath)) {
|
|
throw "Invalid checksum path at ${HashPath}:$lineNumber"
|
|
}
|
|
|
|
$filePath = [System.IO.Path]::GetFullPath((Join-Path $resolvedPackageRoot $relativePath))
|
|
if (-not $filePath.StartsWith($packageRootPrefix, [System.StringComparison]::OrdinalIgnoreCase)) {
|
|
throw "Checksum path escapes package root at ${HashPath}:$lineNumber"
|
|
}
|
|
if (-not (Test-Path -LiteralPath $filePath -PathType Leaf)) {
|
|
throw "Package checksum listed file is missing: $relativePath"
|
|
}
|
|
$normalizedRelativePath = [System.IO.Path]::GetRelativePath($resolvedPackageRoot, $filePath)
|
|
if (-not $listedFiles.Add($normalizedRelativePath)) {
|
|
throw "Duplicate checksum entry for package file: $normalizedRelativePath"
|
|
}
|
|
|
|
$expectedHash = $Matches.hash.ToLowerInvariant()
|
|
$actualHash = (Get-FileHash -LiteralPath $filePath -Algorithm SHA256).Hash.ToLowerInvariant()
|
|
if ($actualHash -ne $expectedHash) {
|
|
throw "Package checksum mismatch for ${relativePath}: expected $expectedHash, got $actualHash"
|
|
}
|
|
$entryCount++
|
|
}
|
|
|
|
if ($entryCount -eq 0) {
|
|
throw "Package checksum file contains no entries: $HashPath"
|
|
}
|
|
|
|
foreach ($file in Get-ChildItem -LiteralPath $PackageRoot -Force -Recurse -File) {
|
|
if ($file.FullName -eq $HashPath) {
|
|
continue
|
|
}
|
|
$relativePath = [System.IO.Path]::GetRelativePath($resolvedPackageRoot, $file.FullName)
|
|
if (-not $listedFiles.Contains($relativePath)) {
|
|
throw "Package contains file missing from SHA256SUMS: $relativePath"
|
|
}
|
|
}
|
|
}
|
|
|
|
function Remove-PathItem {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Path
|
|
)
|
|
|
|
if (-not (Test-Path -LiteralPath $Path)) {
|
|
return
|
|
}
|
|
|
|
$item = Get-Item -LiteralPath $Path -Force
|
|
if (($item.Attributes -band [System.IO.FileAttributes]::ReparsePoint) -ne 0) {
|
|
Remove-Item -LiteralPath $Path -Force
|
|
return
|
|
}
|
|
|
|
if ($item.PSIsContainer) {
|
|
Remove-Item -LiteralPath $Path -Recurse -Force
|
|
return
|
|
}
|
|
|
|
Remove-Item -LiteralPath $Path -Force
|
|
}
|
|
|
|
function New-VersionDirectoryName {
|
|
$stamp = Get-Date -Format 'yyyyMMdd-HHmmss-fff'
|
|
$suffix = [System.Guid]::NewGuid().ToString('N').Substring(0, 8)
|
|
return "$stamp-package-$suffix"
|
|
}
|
|
|
|
function Set-CurrentInstallLink {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$CurrentLinkPath,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$TargetPath
|
|
)
|
|
|
|
$currentParent = Split-Path -Parent $CurrentLinkPath
|
|
if (-not [string]::IsNullOrWhiteSpace($currentParent)) {
|
|
New-Item -ItemType Directory -Force -Path $currentParent | Out-Null
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $CurrentLinkPath) {
|
|
Remove-PathItem -Path $CurrentLinkPath
|
|
}
|
|
|
|
try {
|
|
New-Item -ItemType Junction -Path $CurrentLinkPath -Target $TargetPath | Out-Null
|
|
}
|
|
catch {
|
|
throw "Failed to create current install junction '$CurrentLinkPath' -> '$TargetPath'. Ensure this is running on Windows with a local NTFS-compatible install root. $($_.Exception.Message)"
|
|
}
|
|
if (-not (Test-Path -LiteralPath $CurrentLinkPath)) {
|
|
throw "Current install junction was not created: $CurrentLinkPath"
|
|
}
|
|
}
|
|
|
|
function Remove-ObsoleteVersionDirectories {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$VersionsRoot,
|
|
[AllowNull()]
|
|
[string]$CurrentVersionRoot
|
|
)
|
|
|
|
if (-not (Test-Path -LiteralPath $VersionsRoot)) {
|
|
return
|
|
}
|
|
|
|
foreach ($directory in Get-ChildItem -LiteralPath $VersionsRoot -Directory -Force) {
|
|
if (-not [string]::IsNullOrWhiteSpace($CurrentVersionRoot) -and $directory.FullName -eq $CurrentVersionRoot) {
|
|
continue
|
|
}
|
|
|
|
try {
|
|
Remove-Item -LiteralPath $directory.FullName -Recurse -Force
|
|
}
|
|
catch {
|
|
Write-Warning "Leaving stale toolbox version in place because it is still in use: $($directory.FullName)"
|
|
}
|
|
}
|
|
}
|
|
|
|
function Resolve-CodexHomePath {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$ExplicitCodexHome
|
|
)
|
|
|
|
if (-not [string]::IsNullOrWhiteSpace($ExplicitCodexHome)) {
|
|
return $ExplicitCodexHome
|
|
}
|
|
|
|
if (-not [string]::IsNullOrWhiteSpace($env:CODEX_HOME)) {
|
|
return $env:CODEX_HOME
|
|
}
|
|
|
|
return (Join-Path $env:USERPROFILE '.codex')
|
|
}
|
|
|
|
function Write-CodexSkillOwnershipMarker {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$SkillRoot,
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$InstallKind
|
|
)
|
|
|
|
$markerPath = Join-Path $SkillRoot '.mercury-toolbox-owner.json'
|
|
$payload = [ordered]@{
|
|
owner = 'mercury-toolbox'
|
|
install_kind = $InstallKind
|
|
installed_utc = (Get-Date).ToUniversalTime().ToString('o')
|
|
} | ConvertTo-Json -Compress
|
|
Set-Content -LiteralPath $markerPath -Value $payload -Encoding utf8NoBOM
|
|
}
|
|
|
|
function Assert-CodexSkillInstallAllowed {
|
|
param(
|
|
[AllowNull()]
|
|
[string]$SkillRoot
|
|
)
|
|
|
|
if ([string]::IsNullOrWhiteSpace($SkillRoot) -or -not (Test-Path -LiteralPath $SkillRoot)) {
|
|
return
|
|
}
|
|
|
|
$markerPath = Join-Path $SkillRoot '.mercury-toolbox-owner.json'
|
|
if (-not (Test-Path -LiteralPath $markerPath -PathType Leaf)) {
|
|
throw "Refusing to overwrite unmanaged Codex skill directory: $SkillRoot"
|
|
}
|
|
|
|
try {
|
|
$marker = Get-Content -LiteralPath $markerPath -Raw | ConvertFrom-Json
|
|
}
|
|
catch {
|
|
throw "Refusing to overwrite Codex skill directory with invalid ownership marker: $SkillRoot"
|
|
}
|
|
if ($marker.owner -ne 'mercury-toolbox') {
|
|
throw "Refusing to overwrite Codex skill directory owned by '$($marker.owner)': $SkillRoot"
|
|
}
|
|
}
|
|
|
|
$packageRoot = Split-Path -Parent $PSScriptRoot
|
|
$binSource = Join-Path $packageRoot 'bin'
|
|
$docsSource = Join-Path $packageRoot 'docs'
|
|
$skillsSource = Join-Path $packageRoot 'skills'
|
|
$supportSource = Join-Path $packageRoot 'support'
|
|
$manifestSource = Join-Path $packageRoot 'mercury-toolbox-package.json'
|
|
$hashSource = Join-Path $packageRoot 'SHA256SUMS.txt'
|
|
|
|
if (-not (Test-Path -LiteralPath $binSource)) {
|
|
throw "Package bin directory not found: $binSource"
|
|
}
|
|
if (-not (Test-Path -LiteralPath $docsSource)) {
|
|
throw "Package docs directory not found: $docsSource"
|
|
}
|
|
if (-not (Test-Path -LiteralPath $skillsSource)) {
|
|
throw "Package skills directory not found: $skillsSource"
|
|
}
|
|
|
|
$legacyBinDir = Join-Path $InstallRoot 'bin'
|
|
$versionsRoot = Join-Path $InstallRoot 'versions'
|
|
$currentRoot = Join-Path $InstallRoot 'current'
|
|
$activeBinDir = Join-Path $currentRoot 'bin'
|
|
$versionRoot = Join-Path $versionsRoot (New-VersionDirectoryName)
|
|
$stagingBinDir = Join-Path $versionRoot 'bin'
|
|
$shareRoot = Join-Path $InstallRoot 'share\mercury-toolbox'
|
|
$codexHomeRoot = if ($NoCodexSkillInstall) { $null } else { Resolve-CodexHomePath -ExplicitCodexHome $CodexHome }
|
|
$codexSkillRoot = if ([string]::IsNullOrWhiteSpace([string]$codexHomeRoot)) { $null } else { Join-Path $codexHomeRoot 'skills\mercury-toolbox' }
|
|
$legacyCommandNames = @('context', 'waitfor')
|
|
|
|
Assert-ExistingPathNotReparsePoint -Path $InstallRoot -Description 'InstallRoot'
|
|
Assert-ExistingPathNotReparsePoint -Path $versionsRoot -Description 'versions root'
|
|
Assert-ExistingPathNotReparsePoint -Path $shareRoot -Description 'share root'
|
|
Assert-ExistingTreeHasNoReparsePoints -Path $shareRoot -Description 'share root'
|
|
if ($null -ne $codexSkillRoot) {
|
|
Assert-ExistingPathNotReparsePoint -Path $codexSkillRoot -Description 'Codex skill root'
|
|
Assert-ExistingTreeHasNoReparsePoints -Path $codexSkillRoot -Description 'Codex skill root'
|
|
}
|
|
Assert-PackageSha256Sums -PackageRoot $packageRoot -HashPath $hashSource
|
|
Assert-CodexSkillInstallAllowed -SkillRoot $codexSkillRoot
|
|
|
|
Write-Host "Mercury Toolbox package installer"
|
|
Write-Host "package root: $packageRoot"
|
|
Write-Host "install root: $InstallRoot"
|
|
Write-Host "active bin dir: $activeBinDir"
|
|
Write-Host "versions root: $versionsRoot"
|
|
Write-Host "share dir: $shareRoot"
|
|
if ($null -ne $codexSkillRoot) {
|
|
Write-Host "Codex skill dir: $codexSkillRoot"
|
|
}
|
|
|
|
New-Item -ItemType Directory -Force -Path $stagingBinDir, $shareRoot | Out-Null
|
|
foreach ($legacyName in $legacyCommandNames) {
|
|
$legacyPath = Join-Path $legacyBinDir "$legacyName.exe"
|
|
if (Test-Path -LiteralPath $legacyPath) {
|
|
Remove-Item -LiteralPath $legacyPath -Force
|
|
}
|
|
}
|
|
|
|
$installed = [System.Collections.Generic.List[string]]::new()
|
|
foreach ($commandName in Get-ToolboxCommandNames) {
|
|
$sourcePath = Join-Path $binSource "$commandName.exe"
|
|
if (-not (Test-Path -LiteralPath $sourcePath)) {
|
|
throw "Expected packaged binary not found: $sourcePath"
|
|
}
|
|
|
|
Copy-Item -LiteralPath $sourcePath -Destination (Join-Path $stagingBinDir "$commandName.exe") -Force
|
|
$installed.Add($commandName)
|
|
}
|
|
|
|
foreach ($runtimeFile in Get-ChildItem -LiteralPath $binSource -Filter '*.dll' -File -ErrorAction SilentlyContinue) {
|
|
Copy-Item -LiteralPath $runtimeFile.FullName -Destination (Join-Path $stagingBinDir $runtimeFile.Name) -Force
|
|
}
|
|
|
|
Copy-DirectoryTree -SourcePath $docsSource -DestinationPath (Join-Path $shareRoot 'docs')
|
|
Copy-DirectoryTree -SourcePath $skillsSource -DestinationPath (Join-Path $shareRoot 'skills')
|
|
if (Test-Path -LiteralPath $supportSource) {
|
|
Copy-DirectoryTree -SourcePath $supportSource -DestinationPath (Join-Path $shareRoot 'support')
|
|
}
|
|
Copy-OptionalFile -SourcePath $manifestSource -DestinationPath (Join-Path $shareRoot 'mercury-toolbox-package.json')
|
|
Copy-OptionalFile -SourcePath $hashSource -DestinationPath (Join-Path $shareRoot 'SHA256SUMS.txt')
|
|
|
|
if ($null -ne $codexSkillRoot) {
|
|
$packagedSkillRoot = Join-Path $skillsSource 'mercury-toolbox'
|
|
if (Test-Path -LiteralPath $packagedSkillRoot) {
|
|
Copy-DirectoryTree -SourcePath $packagedSkillRoot -DestinationPath $codexSkillRoot
|
|
Write-CodexSkillOwnershipMarker -SkillRoot $codexSkillRoot -InstallKind 'package'
|
|
}
|
|
}
|
|
|
|
Set-CurrentInstallLink -CurrentLinkPath $currentRoot -TargetPath $versionRoot
|
|
Remove-ObsoleteVersionDirectories -VersionsRoot $versionsRoot -CurrentVersionRoot $versionRoot
|
|
|
|
$pathStatus = 'skipped'
|
|
if (-not $NoPathUpdate) {
|
|
$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
|
|
$userPathChanged = $false
|
|
$userPathRemoval = Remove-PathEntry -ExistingPath $userPath -Entry $legacyBinDir
|
|
if ($userPathRemoval.Changed) {
|
|
$userPath = $userPathRemoval.Value
|
|
$userPathChanged = $true
|
|
}
|
|
$userPathAdd = Add-PathEntry -ExistingPath $userPath -Entry $activeBinDir
|
|
if ($userPathAdd.Changed) {
|
|
$userPath = $userPathAdd.Value
|
|
$userPathChanged = $true
|
|
}
|
|
if ($userPathChanged) {
|
|
[Environment]::SetEnvironmentVariable('Path', $userPath, 'User')
|
|
$pathStatus = 'updated'
|
|
}
|
|
else {
|
|
$pathStatus = 'already_present'
|
|
}
|
|
|
|
$sessionPath = $env:Path
|
|
$sessionRemoval = Remove-PathEntry -ExistingPath $sessionPath -Entry $legacyBinDir
|
|
if ($sessionRemoval.Changed) {
|
|
$sessionPath = $sessionRemoval.Value
|
|
}
|
|
$sessionAdd = Add-PathEntry -ExistingPath $sessionPath -Entry $activeBinDir
|
|
if ($sessionAdd.Changed) {
|
|
$sessionPath = $sessionAdd.Value
|
|
}
|
|
$env:Path = $sessionPath
|
|
}
|
|
|
|
Write-Host ''
|
|
Write-Host "Installed commands ($($installed.Count)):"
|
|
foreach ($commandName in $installed) {
|
|
Write-Host " - $commandName"
|
|
}
|
|
Write-Host "PATH status: $pathStatus"
|
|
Write-Host "AI prompt: $(Join-Path $shareRoot 'docs\ai\mercury-toolbox-ai-prompt.md')"
|
|
Write-Host "Shared skill copy: $(Join-Path $shareRoot 'skills\mercury-toolbox\SKILL.md')"
|
|
Write-Host "Command catalog: $(Join-Path $shareRoot 'skills\mercury-toolbox\references\command-catalog.md')"
|
|
if ($null -ne $codexSkillRoot) {
|
|
Write-Host "Codex skill: $(Join-Path $codexSkillRoot 'SKILL.md')"
|
|
}
|
|
if (-not $NoPathUpdate) {
|
|
Write-Host "Shell note: future shells pick up the new PATH automatically."
|
|
Write-Host "Shell note: if you launched install via 'pwsh -File', reopen this shell or run:"
|
|
Write-Host " `$env:Path = [Environment]::GetEnvironmentVariable('Path','User') + ';' + [Environment]::GetEnvironmentVariable('Path','Machine')"
|
|
}
|
|
Write-Host 'Verification: pathshadow msudo'
|
|
Write-Host 'Verification: msudo status --json'
|
|
Write-Host 'Verification: msudo --help'
|