|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| param(
|
| [switch]$NoVenv,
|
| [switch]$SkipSetup,
|
| [switch]$SkipComputerUse,
|
| [string]$Branch = "main",
|
|
|
|
|
|
|
|
|
|
|
| [string]$Commit = "",
|
|
|
|
|
|
|
|
|
|
|
| [switch]$ForceCommit,
|
| [string]$Tag = "",
|
| [string]$HermesHome = $(if ($env:HERMES_HOME) { $env:HERMES_HOME } else { "$env:LOCALAPPDATA\hermes" }),
|
| [string]$InstallDir = $(if ($env:HERMES_HOME) { "$env:HERMES_HOME\hermes-agent" } else { "$env:LOCALAPPDATA\hermes\hermes-agent" }),
|
|
|
|
|
|
|
|
|
|
|
|
|
| [switch]$Manifest,
|
| [string]$Stage,
|
| [switch]$ProtocolVersion,
|
| [switch]$NonInteractive,
|
| [switch]$Json,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| [switch]$ShowResolvedPaths,
|
|
|
|
|
| [string]$Ensure = "",
|
| [switch]$PostInstall,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| [switch]$IncludeDesktop
|
| )
|
|
|
| $ErrorActionPreference = "Stop"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $ProgressPreference = "SilentlyContinue"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new()
|
| } catch {
|
|
|
|
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $script:LongProfileRoot = $null
|
|
|
| function Write-PathDiag {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| param([string]$Message)
|
| if ($ShowResolvedPaths) { return }
|
| [Console]::Error.WriteLine("[hermes] $Message")
|
| }
|
|
|
| function Get-LongProfileRoot {
|
|
|
|
|
| if ($null -ne $script:LongProfileRoot) { return $script:LongProfileRoot }
|
| $script:LongProfileRoot = ''
|
|
|
|
|
|
|
|
|
|
|
|
|
| $envProfile = [Environment]::GetEnvironmentVariable('USERPROFILE')
|
| $shellProfile = [Environment]::GetFolderPath('UserProfile')
|
| $candidates = @($envProfile, $shellProfile, "$env:HOMEDRIVE$env:HOMEPATH")
|
| foreach ($anchor in @($envProfile, $shellProfile)) {
|
| if ($anchor -and $env:USERNAME) {
|
| $parent = Split-Path -Parent $anchor.TrimEnd('\', '/')
|
| if ($parent) { $candidates += (Join-Path $parent $env:USERNAME) }
|
| }
|
| }
|
|
|
| foreach ($candidate in $candidates) {
|
| if ([string]::IsNullOrWhiteSpace($candidate)) { continue }
|
|
|
|
|
| $candidate = $candidate.TrimEnd('\', '/')
|
| if (-not $candidate) { continue }
|
| if ($candidate -match '~\d') { continue }
|
| try {
|
| if (Test-Path -LiteralPath $candidate -PathType Container) {
|
| $script:LongProfileRoot = $candidate
|
| break
|
| }
|
| } catch {
|
|
|
| }
|
| }
|
|
|
|
|
|
|
|
|
| if ($script:LongProfileRoot) {
|
| Write-PathDiag "long profile root: $script:LongProfileRoot"
|
| } else {
|
| Write-PathDiag "no long profile root found; 8.3 paths left as-is (tried: $($candidates -join ', '))"
|
| }
|
| return $script:LongProfileRoot
|
| }
|
|
|
| function Expand-ShortProfileRoot {
|
|
|
|
|
|
|
| param([string]$Path)
|
|
|
| $longRoot = Get-LongProfileRoot
|
| if (-not $longRoot) { return $Path }
|
| $longRootParent = Split-Path -Parent $longRoot
|
| if (-not $longRootParent) { return $Path }
|
|
|
| $node = $Path
|
| $tail = ''
|
| while ($node -and ($node -match '~\d')) {
|
| $leaf = Split-Path -Leaf $node
|
| $parent = Split-Path -Parent $node
|
| if (-not $parent) { return $Path }
|
| if ($leaf -match '~\d') {
|
|
|
|
|
| if ($parent -ne $longRootParent) { return $Path }
|
| if ($tail) { return (Join-Path $longRoot $tail) }
|
| return $longRoot
|
| }
|
| $tail = if ($tail) { Join-Path $leaf $tail } else { $leaf }
|
| $node = $parent
|
| }
|
| return $Path
|
| }
|
|
|
| function ConvertTo-LongPath {
|
| param([string]$Path)
|
| if ([string]::IsNullOrWhiteSpace($Path)) { return $Path }
|
|
|
|
|
| if ($Path -notmatch '~\d') {
|
| $script:LastResolver = 'skipped-long-path'
|
| return $Path
|
| }
|
|
|
|
|
|
|
| try {
|
| if (-not ([System.Management.Automation.PSTypeName]'HermesInstall.LongPath').Type) {
|
| Add-Type -Namespace 'HermesInstall' -Name 'LongPath' -MemberDefinition @'
|
| [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
| public static extern int GetLongPathNameW(string lpszShortPath, System.Text.StringBuilder lpszLongPath, int cchBuffer);
|
| '@
|
| }
|
| $buffer = New-Object System.Text.StringBuilder 4096
|
| $length = [HermesInstall.LongPath]::GetLongPathNameW($Path, $buffer, $buffer.Capacity)
|
| if ($length -gt $buffer.Capacity) {
|
| $buffer = New-Object System.Text.StringBuilder $length
|
| $length = [HermesInstall.LongPath]::GetLongPathNameW($Path, $buffer, $buffer.Capacity)
|
| }
|
| if ($length -gt 0) {
|
| $expanded = $buffer.ToString()
|
| if ($expanded -and $expanded -notmatch '~\d') {
|
| $script:LastResolver = 'kernel32'
|
| return $expanded
|
| }
|
| }
|
| } catch {
|
|
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| $fso = New-Object -ComObject Scripting.FileSystemObject
|
| $resolved = $null
|
| if ($fso.FolderExists($Path)) { $resolved = $fso.GetFolder($Path).Path }
|
| elseif ($fso.FileExists($Path)) { $resolved = $fso.GetFile($Path).Path }
|
| if ($resolved -and $resolved -notmatch '~\d') {
|
| $script:LastResolver = 'com'
|
| return $resolved
|
| }
|
| } catch {
|
|
|
| }
|
|
|
|
|
| $rebuilt = Expand-ShortProfileRoot $Path
|
| $script:LastResolver = if ($rebuilt -ne $Path) { 'profile-root' } else { 'none' }
|
| return $rebuilt
|
| }
|
|
|
| function Set-LongProfileEnvVars {
|
|
|
|
|
|
|
|
|
| $rewrote = $false
|
| $script:NormalizedPathRewrites = @{}
|
| foreach ($name in @('TEMP', 'TMP', 'LOCALAPPDATA', 'APPDATA', 'USERPROFILE')) {
|
| $current = [Environment]::GetEnvironmentVariable($name)
|
| if (-not $current) { continue }
|
| $expanded = ConvertTo-LongPath $current
|
| if ($expanded -and $expanded -ne $current) {
|
| Set-Item -Path "Env:$name" -Value $expanded
|
| $rewrote = $true
|
| $script:NormalizedPathRewrites[$name] = $expanded
|
|
|
|
|
|
|
|
|
| Write-PathDiag "expanded 8.3 short path in %$name%: $current -> $expanded"
|
| }
|
| }
|
| return $rewrote
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| $script:LastResolver = 'none'
|
| $script:NormalizedProfilePaths = Set-LongProfileEnvVars
|
|
|
|
|
|
|
|
|
|
|
| if ($PSBoundParameters.ContainsKey('HermesHome')) {
|
| $HermesHome = ConvertTo-LongPath $HermesHome
|
| } else {
|
| $HermesHome = ConvertTo-LongPath $(
|
| if ($env:HERMES_HOME) { $env:HERMES_HOME } else { "$env:LOCALAPPDATA\hermes" }
|
| )
|
| }
|
| if ($PSBoundParameters.ContainsKey('InstallDir')) {
|
| $InstallDir = ConvertTo-LongPath $InstallDir
|
| } else {
|
| $InstallDir = ConvertTo-LongPath $(
|
| if ($env:HERMES_HOME) { "$env:HERMES_HOME\hermes-agent" } else { "$env:LOCALAPPDATA\hermes\hermes-agent" }
|
| )
|
| }
|
| if ($script:NormalizedProfilePaths) {
|
|
|
|
|
| Write-PathDiag "resolved install paths: HermesHome=$HermesHome InstallDir=$InstallDir"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $script:ResolvedPathReport = @{
|
| long_profile_root = (Get-LongProfileRoot)
|
| normalized = $script:NormalizedPathRewrites
|
| resolver = $script:LastResolver
|
| temp = $env:TEMP
|
| hermes_home = $HermesHome
|
| install_dir = $InstallDir
|
| }
|
|
|
|
|
|
|
|
|
|
|
| $RepoUrlSsh = "git@github.com:NousResearch/hermes-agent.git"
|
| $RepoUrlHttps = "https://github.com/NousResearch/hermes-agent.git"
|
| $PythonVersion = "3.11"
|
|
|
|
|
|
|
|
|
| $PythonFallbackVersions = @("3.12", "3.13", "3.10")
|
| $PythonFindTimeoutMs = 30000
|
| $NodeVersion = "22"
|
|
|
|
|
|
|
|
|
|
|
| $NpmRange = "<11.10.0 || >=11.17.0"
|
|
|
|
|
|
|
|
|
| $InstallStageProtocolVersion = 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Get-WindowsArch {
|
| try {
|
| $proc = Get-CimInstance -ClassName Win32_Processor -ErrorAction Stop |
|
| Select-Object -First 1
|
| switch ([int]$proc.Architecture) {
|
| 12 { return "arm64" }
|
| 9 { return "x64" }
|
| 0 { return "x86" }
|
| 5 { return "arm" }
|
| }
|
| } catch {
|
|
|
| }
|
|
|
| $envArch = if ($env:PROCESSOR_ARCHITEW6432) {
|
| $env:PROCESSOR_ARCHITEW6432
|
| } else {
|
| $env:PROCESSOR_ARCHITECTURE
|
| }
|
| switch ($envArch) {
|
| "ARM64" { return "arm64" }
|
| "AMD64" { return "x64" }
|
| "x86" { return "x86" }
|
| default {
|
|
|
|
|
| if ([Environment]::Is64BitOperatingSystem) { return "x64" } else { return "x86" }
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
| function Write-Banner {
|
| Write-Host ""
|
| Write-Host "+---------------------------------------------------------+" -ForegroundColor Magenta
|
| Write-Host "| * Hermes Agent Installer |" -ForegroundColor Magenta
|
| Write-Host "+---------------------------------------------------------+" -ForegroundColor Magenta
|
| Write-Host "| An open source AI agent by Nous Research. |" -ForegroundColor Magenta
|
| Write-Host "+---------------------------------------------------------+" -ForegroundColor Magenta
|
| Write-Host ""
|
| }
|
|
|
| function Write-Info {
|
| param([string]$Message)
|
| Write-Host "-> $Message" -ForegroundColor Cyan
|
| }
|
|
|
| function Write-Success {
|
| param([string]$Message)
|
| Write-Host "[OK] $Message" -ForegroundColor Green
|
| }
|
|
|
| function Write-Warn {
|
| param([string]$Message)
|
| Write-Host "[!] $Message" -ForegroundColor Yellow
|
| }
|
|
|
| function Write-Err {
|
| param([string]$Message)
|
| Write-Host "[X] $Message" -ForegroundColor Red
|
| }
|
|
|
| function Invoke-NativeWithRelaxedErrorAction {
|
| param([scriptblock]$Script)
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
| & $Script
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| }
|
| }
|
| function Discard-LockfileChurn {
|
| param([string]$Repo = $InstallDir)
|
|
|
| if (-not $Repo -or -not (Test-Path (Join-Path $Repo ".git"))) { return }
|
|
|
| try {
|
| $diff = & git -c windows.appendAtomically=false -C $Repo diff --name-only 2>$null
|
| if ($LASTEXITCODE -ne 0 -or -not $diff) { return }
|
|
|
| $dirtyPackageDirs = [System.Collections.Generic.HashSet[string]]::new(
|
| [System.StringComparer]::OrdinalIgnoreCase
|
| )
|
| foreach ($path in $diff) {
|
| if ($path -like "*package.json") {
|
| $null = $dirtyPackageDirs.Add((Split-Path $path -Parent))
|
| }
|
| }
|
|
|
| $dirtyLocks = [System.Collections.Generic.List[string]]::new()
|
| foreach ($path in $diff) {
|
| if ($path -notlike "*package-lock.json") { continue }
|
| $lockDir = Split-Path $path -Parent
|
| if ($dirtyPackageDirs.Contains($lockDir)) { continue }
|
| $dirtyLocks.Add($path)
|
| }
|
|
|
| if ($dirtyLocks.Count -eq 0) { return }
|
| & git -c windows.appendAtomically=false -C $Repo checkout -- @($dirtyLocks) 2>$null
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Info "Discarded npm lockfile churn ($($dirtyLocks.Count) file(s))"
|
| }
|
| } catch {
|
|
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Show-NpmCertHint {
|
| param([string]$NpmOutput)
|
| if (-not $NpmOutput) { return $false }
|
| $isCertError = $NpmOutput -match "unable to get local issuer certificate" `
|
| -or $NpmOutput -match "self.signed certificate" `
|
| -or $NpmOutput -match "UNABLE_TO_GET_ISSUER_CERT_LOCALLY" `
|
| -or $NpmOutput -match "SELF_SIGNED_CERT_IN_CHAIN" `
|
| -or $NpmOutput -match "CERT_HAS_EXPIRED"
|
| if (-not $isCertError) { return $false }
|
| Write-Warn "This looks like a TLS certificate-trust failure, not a permissions problem."
|
| Write-Info " A corporate proxy or antivirus is likely intercepting HTTPS and presenting a"
|
| Write-Info " certificate Node.js doesn't trust. To fix, point Node at your org's root CA:"
|
| Write-Info " 1. Get the corporate root CA as a .pem/.crt from your IT team."
|
| Write-Info " 2. setx NODE_EXTRA_CA_CERTS `"C:\path\to\corp-ca.pem`""
|
| Write-Info " 3. Open a NEW terminal (so the env var takes effect) and re-run the installer."
|
| Write-Info " Quick (less secure) alternative -- disable TLS verification just for the install:"
|
| Write-Info " npm config set strict-ssl false (re-enable afterwards: npm config set strict-ssl true)"
|
| return $true
|
| }
|
|
|
| function Write-NpmDebugLogTail {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| param(
|
| [string]$NpmOutput,
|
| [int]$TailLines = 200
|
| )
|
| $logPath = $null
|
|
|
| if ($NpmOutput -and $NpmOutput -match "A complete log of this run can be found in:\s*(?<path>[^\r\n]+)") {
|
| $candidate = $Matches['path'].Trim()
|
| if (Test-Path -LiteralPath $candidate) { $logPath = $candidate }
|
| }
|
|
|
|
|
| if (-not $logPath) {
|
| try {
|
| $npm = Resolve-NpmCmd
|
| if ($npm) {
|
| $prevEAPLocal = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| $cacheDir = (& $npm config get cache 2>$null | Select-Object -Last 1)
|
| $ErrorActionPreference = $prevEAPLocal
|
| if ($cacheDir) {
|
| $logsDir = Join-Path ("$cacheDir").Trim() "_logs"
|
| if (Test-Path -LiteralPath $logsDir) {
|
| $newest = Get-ChildItem -LiteralPath $logsDir -Filter "*-debug-*.log" -ErrorAction SilentlyContinue |
|
| Sort-Object LastWriteTime -Descending | Select-Object -First 1
|
| if ($newest) { $logPath = $newest.FullName }
|
| }
|
| }
|
| }
|
| } catch { }
|
| }
|
| if (-not $logPath) {
|
| Write-Warn "npm debug log could not be located -- no further npm detail available"
|
| return
|
| }
|
| $tail = $null
|
| try {
|
| $tail = Get-Content -LiteralPath $logPath -Tail $TailLines -ErrorAction Stop
|
| } catch {
|
| Write-Warn "Could not read npm debug log ${logPath}: $($_.Exception.Message)"
|
| return
|
| }
|
| Write-Warn "---- npm debug log: last $TailLines lines of $logPath ----"
|
| foreach ($line in $tail) { Write-Host " $line" -ForegroundColor DarkGray }
|
| Write-Warn "---- end npm debug log ----"
|
| }
|
|
|
|
|
|
|
| function Resolve-NpmCmd {
|
| $npmCmd = Get-Command npm -ErrorAction SilentlyContinue
|
| if (-not $npmCmd) { return $null }
|
| $npmExe = $npmCmd.Source
|
| if ($npmExe -like "*.ps1") {
|
| $npmCmdSibling = Join-Path (Split-Path $npmExe -Parent) "npm.cmd"
|
| if (Test-Path $npmCmdSibling) { return $npmCmdSibling }
|
| }
|
| return $npmExe
|
| }
|
|
|
| function Find-SystemBrowser {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $override = $env:AGENT_BROWSER_EXECUTABLE_PATH
|
| if ([string]::IsNullOrWhiteSpace($override)) { return $null }
|
| if (Test-Path $override) { return $override }
|
| return $null
|
| }
|
|
|
| function Write-BrowserEnv {
|
| param([string]$BrowserPath)
|
| if (-not (Test-Path $HermesHome)) {
|
| New-Item -ItemType Directory -Force -Path $HermesHome | Out-Null
|
| }
|
| $envFile = Join-Path $HermesHome ".env"
|
| if (-not (Test-Path $envFile)) {
|
| Set-Content -Path $envFile -Value "AGENT_BROWSER_EXECUTABLE_PATH=$BrowserPath" -Encoding UTF8
|
| return
|
| }
|
| $content = Get-Content $envFile -Raw -ErrorAction SilentlyContinue
|
| if ($content -and $content -match "AGENT_BROWSER_EXECUTABLE_PATH=") { return }
|
| Add-Content -Path $envFile -Value "AGENT_BROWSER_EXECUTABLE_PATH=$BrowserPath" -Encoding UTF8
|
| }
|
|
|
| function Install-AgentBrowser {
|
| $npm = Resolve-NpmCmd
|
| if (-not $npm) {
|
| Write-Err "npm not found -- install Node.js first"
|
| throw "npm not found"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "Installing camofox browser server..."
|
| $prefixDir = Join-Path $HermesHome "node"
|
| if (-not (Test-Path $prefixDir)) {
|
| New-Item -ItemType Directory -Path $prefixDir -Force | Out-Null
|
| }
|
| $npmLog = [System.IO.Path]::GetTempFileName()
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| & $npm install -g --prefix $prefixDir --silent --ignore-scripts "@askjo/camofox-browser@^1.5.2" 2>&1 | Tee-Object -FilePath $npmLog | Out-Null
|
| $npmExit = $LASTEXITCODE
|
| $ErrorActionPreference = $prevEAP
|
| if ($npmExit -ne 0) {
|
| $npmDetail = Get-Content $npmLog -Raw -ErrorAction SilentlyContinue
|
| Remove-Item $npmLog -Force -ErrorAction SilentlyContinue
|
| Write-Err "npm install -g failed (exit $npmExit): $npmDetail"
|
| Show-NpmCertHint $npmDetail | Out-Null
|
|
|
|
|
| Write-NpmDebugLogTail -NpmOutput $npmDetail
|
| throw "npm install failed"
|
| }
|
| Remove-Item $npmLog -Force -ErrorAction SilentlyContinue
|
|
|
| $sysBrowser = Find-SystemBrowser
|
| if ($sysBrowser) {
|
| Write-BrowserEnv -BrowserPath $sysBrowser
|
| Write-Info "Explicit browser override set -- Chromium download will be skipped when agent-browser installs on demand"
|
| }
|
| Write-Success "Agent-browser ready"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Get-PowerShellHostExe {
|
| try {
|
| $hostExe = (Get-Process -Id $PID).Path
|
| if ($hostExe -and (Test-Path $hostExe)) {
|
| $leaf = Split-Path $hostExe -Leaf
|
|
|
|
|
|
|
| if ($leaf -match '^(?i:powershell|pwsh)\.exe$') { return $hostExe }
|
| }
|
| } catch { }
|
| foreach ($candidate in @("powershell", "pwsh")) {
|
| $cmd = Get-Command $candidate -CommandType Application -ErrorAction SilentlyContinue |
|
| Select-Object -First 1
|
| if ($cmd -and $cmd.Source) { return $cmd.Source }
|
| }
|
|
|
| return "powershell"
|
| }
|
|
|
| function Install-Uv {
|
|
|
|
|
|
|
|
|
| $managedUv = Join-Path $HermesHome "bin\uv.exe"
|
|
|
| if (Test-Path $managedUv) {
|
| $script:UvCmd = $managedUv
|
| $version = & $managedUv --version
|
| Write-Success "Managed uv found ($version)"
|
| return $true
|
| }
|
|
|
| Write-Info "Installing managed uv into $HermesHome\bin ..."
|
| New-Item -ItemType Directory -Path (Join-Path $HermesHome "bin") -Force | Out-Null
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
| $ErrorActionPreference = "Continue"
|
| $env:UV_INSTALL_DIR = Join-Path $HermesHome "bin"
|
|
|
|
|
|
|
| $psHostExe = Get-PowerShellHostExe
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $installerOutput = @()
|
| $astralOut = @()
|
| & $psHostExe -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" 2>&1 | Tee-Object -Variable astralOut | Out-Null
|
| $installerOutput += "--- uv installer source: astral.sh ---"
|
| $installerOutput += @($astralOut | ForEach-Object { "$_" })
|
| if (Test-Path $managedUv) {
|
| Write-Info "uv installer succeeded via astral.sh"
|
| } else {
|
| Write-Info "astral.sh uv installer did not produce $managedUv; trying GitHub releases mirror ..."
|
| $ghOut = @()
|
| & $psHostExe -ExecutionPolicy ByPass -c "irm https://github.com/astral-sh/uv/releases/latest/download/uv-installer.ps1 | iex" 2>&1 | Tee-Object -Variable ghOut | Out-Null
|
| $installerOutput += "--- uv installer source: GitHub releases ---"
|
| $installerOutput += @($ghOut | ForEach-Object { "$_" })
|
| if (Test-Path $managedUv) {
|
| Write-Info "uv installer succeeded via GitHub releases"
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not (Test-Path $managedUv)) {
|
| $existingUv = $null
|
| $uvOnPath = Get-Command uv -CommandType Application -ErrorAction SilentlyContinue |
|
| Select-Object -First 1
|
| if ($uvOnPath -and $uvOnPath.Source -and (Test-Path $uvOnPath.Source)) {
|
| $existingUv = $uvOnPath.Source
|
| }
|
| if (-not $existingUv) {
|
| $defaultUv = Join-Path $env:USERPROFILE ".local\bin\uv.exe"
|
| if (Test-Path $defaultUv) { $existingUv = $defaultUv }
|
| }
|
| if ($existingUv) {
|
| Write-Info "Salvaging existing uv from $existingUv"
|
| try {
|
| Copy-Item $existingUv $managedUv -Force
|
|
|
|
|
| $null = & $managedUv --version
|
| } catch {
|
| Write-Info "Existing uv at $existingUv could not be salvaged: $_"
|
| Remove-Item $managedUv -Force -ErrorAction SilentlyContinue
|
| }
|
| }
|
| }
|
|
|
| $ErrorActionPreference = $prevEAP
|
|
|
| if (Test-Path $managedUv) {
|
| $script:UvCmd = $managedUv
|
| $version = & $managedUv --version
|
| Write-Success "Managed uv installed ($version)"
|
| return $true
|
| }
|
|
|
| Write-Err "uv installed but not found at $managedUv"
|
| if ($installerOutput.Count -gt 0) {
|
| Write-Info "uv installer output (last 15 lines):"
|
| $installerOutput | Select-Object -Last 15 | ForEach-Object { Write-Info " $_" }
|
| }
|
| Write-Info "Install manually: https://docs.astral.sh/uv/getting-started/installation/"
|
| return $false
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Write-Err "Failed to install uv: $_"
|
| Write-Info "Install manually: https://docs.astral.sh/uv/getting-started/installation/"
|
| return $false
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Sync-EnvPath {
|
| $env:Path = [Environment]::GetEnvironmentVariable("Path", "User") + ";" + [Environment]::GetEnvironmentVariable("Path", "Machine")
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Ensure-NodeExeOnPath {
|
| $nodeCmd = Get-Command node -ErrorAction SilentlyContinue
|
| if (-not $nodeCmd) { return $false }
|
|
|
| $nodeExeDir = Split-Path $nodeCmd.Source -Parent
|
| if (-not $nodeExeDir) { return $false }
|
|
|
| $pathParts = $env:Path -split ";"
|
| if ($pathParts -notcontains $nodeExeDir) {
|
| $env:Path = "$nodeExeDir;$env:Path"
|
| }
|
| return $true
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Set-ManagedNodeFirstOnUserPath {
|
| param([string]$NodeDir)
|
|
|
| if (-not $NodeDir) { return }
|
|
|
| $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
|
| $items = if ($userPath) { @($userPath -split ";") } else { @() }
|
|
|
| $rest = @($items | Where-Object { $_ -ne $NodeDir })
|
| $updated = (@($NodeDir) + $rest) -join ";"
|
|
|
| if ($updated -ne $userPath) {
|
| [Environment]::SetEnvironmentVariable("Path", $updated, "User")
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function Get-NpmRange {
|
| $manifest = Join-Path $InstallDir "package.json"
|
| if (Test-Path $manifest) {
|
| try {
|
| $engines = (Get-Content $manifest -Raw | ConvertFrom-Json).engines
|
| if ($engines -and $engines.npm) { return [string]$engines.npm }
|
| } catch { }
|
| }
|
| return $NpmRange
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function ConvertTo-NpmVersion {
|
| param([string]$Version)
|
|
|
| if (-not $Version) { return $null }
|
|
|
| $core = ($Version.Trim() -replace '^v', '' -replace '-.*$', '')
|
| $parts = @($core -split '\.')
|
| if ($parts.Count -lt 1 -or $parts.Count -gt 3) { return $null }
|
| foreach ($part in $parts) {
|
| if ($part -notmatch '^\d+$') { return $null }
|
| }
|
| while ($parts.Count -lt 3) { $parts += '0' }
|
|
|
| try {
|
| return [version]($parts -join '.')
|
| } catch {
|
| return $null
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Test-NpmVersionOk {
|
| param(
|
| [string]$Version,
|
| [string]$Range = (Get-NpmRange)
|
| )
|
|
|
| $actual = ConvertTo-NpmVersion $Version
|
| if (-not $actual -or -not $Range) { return $false }
|
|
|
| foreach ($alternative in @($Range -split '\s*\|\|\s*')) {
|
| $clause = $alternative.Trim()
|
| if (-not $clause) { continue }
|
|
|
| $comparators = [regex]::Matches(
|
| $clause,
|
| '(?:^|\s)(<=|>=|<|>)\s*(\d+(?:\.\d+){0,2})(?=\s|$)'
|
| )
|
| if ($comparators.Count -eq 0) { continue }
|
|
|
| $remainder = [regex]::Replace(
|
| $clause,
|
| '(?:^|\s)(?:<=|>=|<|>)\s*\d+(?:\.\d+){0,2}(?=\s|$)',
|
| ''
|
| ).Trim()
|
| if ($remainder) { continue }
|
|
|
| $matchesClause = $true
|
| foreach ($comparator in $comparators) {
|
| $target = ConvertTo-NpmVersion $comparator.Groups[2].Value
|
| if (-not $target) {
|
| $matchesClause = $false
|
| break
|
| }
|
|
|
| $matchesComparator = switch ($comparator.Groups[1].Value) {
|
| '<' { $actual -lt $target }
|
| '<=' { $actual -le $target }
|
| '>' { $actual -gt $target }
|
| '>=' { $actual -ge $target }
|
| default { $false }
|
| }
|
| if (-not $matchesComparator) {
|
| $matchesClause = $false
|
| break
|
| }
|
| }
|
|
|
| if ($matchesClause) { return $true }
|
| }
|
|
|
| return $false
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Update-ManagedNpm {
|
| param([string]$NodeDir)
|
|
|
| $npmCmd = Join-Path $NodeDir "npm.cmd"
|
| if (-not (Test-Path $npmCmd)) { return $false }
|
|
|
| $range = Get-NpmRange
|
|
|
|
|
|
|
| try {
|
| $have = (& $npmCmd --version 2>$null | Select-Object -First 1)
|
| if ($have -and (Test-NpmVersionOk $have $range)) { return $true }
|
| } catch { }
|
|
|
|
|
|
|
|
|
|
|
| if (Test-ManagedNodeInUse $NodeDir) {
|
| Write-Warn "Hermes-managed Node.js is in use by a running app; skipping the bundled npm upgrade (applies on a later update with the app closed)."
|
| return $false
|
| }
|
|
|
| Write-Info "Upgrading bundled npm to satisfy $range ..."
|
|
|
| $tmpCwd = Join-Path $env:TEMP ("hermes-npm-upgrade-" + [Guid]::NewGuid().ToString("N"))
|
| New-Item -ItemType Directory -Force -Path $tmpCwd | Out-Null
|
| $prevAge = $env:npm_config_min_release_age
|
| $prevCI = $env:CI
|
| $prevEAP = $ErrorActionPreference
|
| Push-Location $tmpCwd
|
| try {
|
| $env:npm_config_min_release_age = "0"
|
| $env:CI = "1"
|
|
|
|
|
|
|
| $ErrorActionPreference = "Continue"
|
| & $npmCmd install --global --prefix $NodeDir "npm@$range" `
|
| --no-fund --no-audit --progress=false 2>&1 | Out-Null
|
| $exit = $LASTEXITCODE
|
| } catch {
|
| $exit = 1
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| Pop-Location
|
| $env:npm_config_min_release_age = $prevAge
|
| $env:CI = $prevCI
|
| Remove-Item -Recurse -Force $tmpCwd -ErrorAction SilentlyContinue
|
| }
|
|
|
| if ($exit -ne 0) {
|
| Write-Warn "Could not upgrade bundled npm to $range -- ``npm ci`` may fail with EBADENGINE."
|
| Write-Info "Fix manually: npm install -g --prefix `"$NodeDir`" npm@`"$range`""
|
| return $false
|
| }
|
|
|
| Write-Success "npm $(& $npmCmd --version 2>$null) installed"
|
| return $true
|
| }
|
|
|
| function Test-ManagedNodeInUse {
|
| param([string]$NodeDir)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| return @(
|
| Get-CimInstance Win32_Process -ErrorAction SilentlyContinue |
|
| Where-Object {
|
| ($_.ExecutablePath -like "$NodeDir\*") -or
|
| ($_.CommandLine -like "*$NodeDir*")
|
| }
|
| ).Count -gt 0
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Resolve-UvCmd {
|
|
|
|
|
| if ($script:UvCmd) {
|
| if ($script:UvCmd -eq "uv") {
|
|
|
|
|
| if (Get-Command uv -ErrorAction SilentlyContinue) { return }
|
| } elseif (Test-Path $script:UvCmd) {
|
| return
|
| }
|
|
|
| }
|
|
|
|
|
| $managedUv = Join-Path $HermesHome "bin\uv.exe"
|
| if (Test-Path $managedUv) {
|
| $script:UvCmd = $managedUv
|
| return
|
| }
|
|
|
|
|
|
|
| if (Get-Command uv -ErrorAction SilentlyContinue) {
|
| $script:UvCmd = "uv"
|
| return
|
| }
|
|
|
|
|
|
|
| $env:Path = [Environment]::GetEnvironmentVariable("Path", "User") + ";" + [Environment]::GetEnvironmentVariable("Path", "Machine")
|
| if (Get-Command uv -ErrorAction SilentlyContinue) {
|
| $script:UvCmd = "uv"
|
| return
|
| }
|
|
|
| throw "uv is not installed. Run install.ps1 -Stage uv first."
|
| }
|
|
|
| function Initialize-ManagedPythonEnvironment {
|
|
|
|
|
|
|
| foreach ($name in @(
|
| "CONDA_DEFAULT_ENV", "CONDA_PREFIX", "UV_PROJECT_ENVIRONMENT",
|
| "UV_NO_MANAGED_PYTHON", "UV_PYTHON", "UV_PYTHON_DOWNLOADS",
|
| "UV_SYSTEM_PYTHON", "VIRTUAL_ENV", "PYTHONHOME", "PYTHONPATH"
|
| )) {
|
| Remove-Item -Path "Env:$name" -ErrorAction SilentlyContinue
|
| }
|
|
|
| $managedRoot = Join-Path $InstallDir ".hermes-runtime\python"
|
| New-Item -ItemType Directory -Force -Path $managedRoot | Out-Null
|
| $env:UV_MANAGED_PYTHON = "1"
|
| $env:UV_NO_CONFIG = "1"
|
| $env:UV_PYTHON_INSTALL_BIN = "0"
|
| $env:UV_PYTHON_INSTALL_DIR = $managedRoot
|
| $env:UV_PYTHON_INSTALL_REGISTRY = "0"
|
| return [System.IO.Path]::GetFullPath($managedRoot)
|
| }
|
|
|
| function Resolve-AvailablePythonVersion {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| [string]$managedRoot = Initialize-ManagedPythonEnvironment
|
| $managedPrefix = $managedRoot.TrimEnd('\') + '\'
|
| $candidates = @($PythonVersion) + $PythonFallbackVersions
|
| $seen = @{}
|
| foreach ($ver in $candidates) {
|
| if (-not $ver -or $seen.ContainsKey($ver)) { continue }
|
| $seen[$ver] = $true
|
| $process = $null
|
| try {
|
|
|
|
|
|
|
|
|
| $process = New-Object System.Diagnostics.Process
|
| $startInfo = New-Object System.Diagnostics.ProcessStartInfo
|
| $startInfo.FileName = $UvCmd
|
| $startInfo.Arguments = "python find $ver --managed-python --no-config"
|
| $startInfo.UseShellExecute = $false
|
| $startInfo.CreateNoWindow = $true
|
| $startInfo.RedirectStandardOutput = $true
|
| $startInfo.RedirectStandardError = $true
|
| $process.StartInfo = $startInfo
|
| if (-not $process.Start()) { continue }
|
| $stdoutTask = $process.StandardOutput.ReadToEndAsync()
|
| $stderrTask = $process.StandardError.ReadToEndAsync()
|
| if (-not $process.WaitForExit($PythonFindTimeoutMs)) {
|
| try { $process.Kill() } catch { }
|
| $process.WaitForExit()
|
| throw "uv python find $ver timed out after $PythonFindTimeoutMs ms"
|
| }
|
| $stdout = $stdoutTask.Result
|
| $stderrTask.Result | Out-Null
|
| if ($process.ExitCode -ne 0) { continue }
|
| [string]$foundPath = ($stdout.Trim() -split "`r?`n") | Select-Object -Last 1
|
| if ($foundPath) {
|
| $absolute = [System.IO.Path]::GetFullPath($foundPath)
|
| if ($absolute.StartsWith($managedPrefix, [System.StringComparison]::OrdinalIgnoreCase)) {
|
| return [PSCustomObject]@{
|
| Path = $absolute
|
| Version = $ver
|
| }
|
| }
|
| }
|
| } catch {
|
| throw "Failed to resolve Hermes-managed Python $ver`: $_"
|
| } finally {
|
| if ($process) { $process.Dispose() }
|
| }
|
| }
|
| return $null
|
| }
|
|
|
| function Test-Python {
|
| Initialize-ManagedPythonEnvironment | Out-Null
|
| Write-Info "Checking Python $PythonVersion..."
|
|
|
|
|
| try {
|
| $resolvedPython = Resolve-AvailablePythonVersion
|
| if ($resolvedPython) {
|
| $ver = & $resolvedPython.Path --version 2>$null
|
| Write-Success "Python found: $ver"
|
| return $true
|
| }
|
| } catch { }
|
|
|
|
|
| Write-Info "Python $PythonVersion not found, installing via uv..."
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $ErrorActionPreference = "Continue"
|
| $uvOutput = & $UvCmd python install $PythonVersion --no-bin --no-registry --no-config 2>&1
|
| $uvExitCode = $LASTEXITCODE
|
| $ErrorActionPreference = $prevEAP
|
|
|
|
|
|
|
| $resolvedPython = Resolve-AvailablePythonVersion
|
| if ($resolvedPython) {
|
| $ver = & $resolvedPython.Path --version 2>$null
|
| Write-Success "Python installed: $ver"
|
| return $true
|
| }
|
|
|
|
|
| if ($uvExitCode -ne 0) {
|
| Write-Warn "uv python install output:"
|
| Write-Host $uvOutput -ForegroundColor DarkGray
|
| }
|
| } catch {
|
|
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Write-Warn "uv python install error: $_"
|
| }
|
|
|
|
|
|
|
|
|
| foreach ($fallbackVer in $PythonFallbackVersions) {
|
| try {
|
| Write-Info "Trying managed Python fallback $fallbackVer..."
|
| $previousFallbackEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| & $UvCmd python install $fallbackVer --no-bin --no-registry --no-config 2>&1 | Out-Null
|
| $ErrorActionPreference = $previousFallbackEAP
|
| $resolvedPython = Resolve-AvailablePythonVersion
|
| if ($resolvedPython) {
|
| $ver = & $resolvedPython.Path --version 2>$null
|
| Write-Success "Python fallback installed: $ver"
|
| return $true
|
| }
|
| } catch {
|
| if ($previousFallbackEAP) { $ErrorActionPreference = $previousFallbackEAP }
|
| }
|
| }
|
|
|
| Write-Err "Failed to install Python $PythonVersion"
|
| Write-Info "Check network access to uv's managed Python downloads, then retry."
|
| return $false
|
| }
|
|
|
| $script:GitInstallFailureReason = $null
|
| $script:GitBashPath = $null
|
| $script:GitBashProbeOutput = $null
|
|
|
| function Test-GitBashCompatibility {
|
| |
| |
| |
| |
| |
|
|
| param([Parameter(Mandatory = $true)][string]$BashPath)
|
|
|
| $script:GitBashProbeOutput = $null
|
| if (-not (Test-Path -LiteralPath $BashPath)) {
|
| $script:GitBashProbeOutput = "bash.exe was not found at $BashPath"
|
| return $false
|
| }
|
|
|
| $process = New-Object System.Diagnostics.Process
|
| try {
|
| $startInfo = New-Object System.Diagnostics.ProcessStartInfo
|
| $startInfo.FileName = $BashPath
|
| $startInfo.Arguments = '--noprofile --norc -c "/usr/bin/true; /usr/bin/cat --version >/dev/null"'
|
| $startInfo.UseShellExecute = $false
|
| $startInfo.CreateNoWindow = $true
|
| $startInfo.RedirectStandardOutput = $true
|
| $startInfo.RedirectStandardError = $true
|
| $process.StartInfo = $startInfo
|
|
|
| if (-not $process.Start()) {
|
| $script:GitBashProbeOutput = "bash.exe did not start"
|
| return $false
|
| }
|
| if (-not $process.WaitForExit(15000)) {
|
| try { $process.Kill() } catch { }
|
| $script:GitBashProbeOutput = "Git Bash compatibility probe timed out"
|
| return $false
|
| }
|
|
|
| $stdout = $process.StandardOutput.ReadToEnd()
|
| $stderr = $process.StandardError.ReadToEnd()
|
| $script:GitBashProbeOutput = ("$stdout`n$stderr").Trim()
|
| return ($process.ExitCode -eq 0)
|
| } catch {
|
| $script:GitBashProbeOutput = $_.Exception.Message
|
| return $false
|
| } finally {
|
| $process.Dispose()
|
| }
|
| }
|
|
|
| function Test-MandatoryAslrEnabled {
|
|
|
| try {
|
| $cmd = Get-Command Get-ProcessMitigation -ErrorAction SilentlyContinue
|
| if (-not $cmd) { return $false }
|
| $mitigations = & $cmd -System
|
| $value = $mitigations.Aslr.ForceRelocateImages
|
| return ($null -ne $value -and $value.ToString().ToUpperInvariant() -eq "ON")
|
| } catch {
|
| return $false
|
| }
|
| }
|
|
|
| function Get-GitRootFromBashPath {
|
| param([Parameter(Mandatory = $true)][string]$BashPath)
|
|
|
| $binDir = Split-Path -Path $BashPath -Parent
|
| if ((Split-Path -Path $binDir -Leaf) -ine "bin") {
|
| return (Split-Path -Path $binDir -Parent)
|
| }
|
|
|
| $parent = Split-Path -Path $binDir -Parent
|
| if ((Split-Path -Path $parent -Leaf) -ieq "usr") {
|
| return (Split-Path -Path $parent -Parent)
|
| }
|
| return $parent
|
| }
|
|
|
| function New-GitBashAslrFailureReason {
|
| param([Parameter(Mandatory = $true)][string]$BashPath)
|
|
|
| $gitRoot = Get-GitRootFromBashPath -BashPath $BashPath
|
| $escapedRoot = $gitRoot -replace "'", "''"
|
| return @(
|
| "Git Bash at $BashPath cannot launch required MSYS child processes because Windows Mandatory ASLR (ForceRelocateImages) is enabled system-wide. Reinstalling Git will not change this policy."
|
| "Open PowerShell as Administrator and run:"
|
| "`$gitRoot = '$escapedRoot'"
|
| 'Get-Item "$gitRoot\bin\bash.exe", "$gitRoot\usr\bin\*.exe" -ErrorAction SilentlyContinue | ForEach-Object { Set-ProcessMitigation -Name $_.FullName -Disable ForceRelocateImages }'
|
| "Then rerun Hermes setup. If the override is blocked or later re-applied, ask your Windows administrator to allow this per-program exception."
|
| ) -join [Environment]::NewLine
|
| }
|
|
|
| function Install-Git {
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| $script:GitInstallFailureReason = $null
|
| Write-Info "Checking Git..."
|
|
|
| if (Get-Command git -ErrorAction SilentlyContinue) {
|
| $version = git --version
|
| Write-Success "Git found ($version)"
|
| Set-GitBashEnvVar
|
| if ($script:GitBashPath -and (Test-GitBashCompatibility -BashPath $script:GitBashPath)) {
|
| Write-Success "Git Bash can launch MSYS programs"
|
| return $true
|
| }
|
|
|
| if ($script:GitBashPath -and (Test-MandatoryAslrEnabled)) {
|
| $script:GitInstallFailureReason = New-GitBashAslrFailureReason -BashPath $script:GitBashPath
|
| Write-Err $script:GitInstallFailureReason
|
| return $false
|
| }
|
|
|
| if ($script:GitBashPath) {
|
| $probeDetail = if ($script:GitBashProbeOutput) { ": $script:GitBashProbeOutput" } else { "" }
|
| Write-Warn "System Git Bash could not launch required MSYS programs$probeDetail"
|
| } else {
|
| Write-Warn "Git is on PATH, but its Git Bash installation could not be located."
|
| }
|
| Write-Info "Trying a Hermes-managed PortableGit install instead..."
|
| }
|
|
|
|
|
|
|
|
|
| Write-Info "Git not found -- downloading PortableGit to $HermesHome\git\ ..."
|
| Write-Info "(no admin rights required; isolated from any system Git install)"
|
|
|
| try {
|
| $arch = Get-WindowsArch
|
| if ($arch -eq 'arm64') {
|
| $assetTag = 'arm64'
|
| $downloadIsZip = $false
|
| } elseif ($arch -eq 'x64') {
|
| $assetTag = '64-bit'
|
| $downloadIsZip = $false
|
| } else {
|
|
|
|
|
| $assetTag = '32-bit-mingit'
|
| $downloadIsZip = $true
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $gitTag = "v2.54.0.windows.1"
|
| $gitVer = "2.54.0"
|
| $gitVerTag = "$gitVer.windows.1"
|
|
|
| if ($arch -eq "32-bit-mingit") {
|
| Write-Warn "32-bit Windows detected -- PortableGit is 64-bit only. Installing MinGit 32-bit as a last resort; bash-dependent Hermes features (terminal tool, agent-browser) will not work on this machine."
|
| $assetName = "MinGit-$gitVer-32-bit.zip"
|
| $downloadIsZip = $true
|
| } elseif ($arch -eq "arm64") {
|
| $assetName = "PortableGit-$gitVer-arm64.7z.exe"
|
| $downloadIsZip = $false
|
| } else {
|
| $assetName = "PortableGit-$gitVer-64-bit.7z.exe"
|
| $downloadIsZip = $false
|
| }
|
|
|
| $downloadUrl = "https://github.com/git-for-windows/git/releases/download/$gitTag/$assetName"
|
| $downloadExt = if ($downloadIsZip) { "zip" } else { "7z.exe" }
|
| $tmpFile = "$env:TEMP\$assetName"
|
| $gitDir = "$HermesHome\git"
|
|
|
| Write-Info "Downloading $assetName (Git for Windows $gitVerTag)..."
|
| Invoke-WebRequest -Uri $downloadUrl -OutFile $tmpFile -UseBasicParsing
|
|
|
| if (Test-Path $gitDir) {
|
| Write-Info "Removing previous Git install at $gitDir ..."
|
| Remove-Item -Recurse -Force $gitDir
|
| }
|
| New-Item -ItemType Directory -Path $gitDir -Force | Out-Null
|
|
|
| if ($downloadIsZip) {
|
| Expand-Archive -Path $tmpFile -DestinationPath $gitDir -Force
|
| } else {
|
|
|
|
|
|
|
| Write-Info "Extracting PortableGit to $gitDir ..."
|
| $extractProc = Start-Process -FilePath $tmpFile `
|
| -ArgumentList "-o`"$gitDir`"", "-y" `
|
| -NoNewWindow -Wait -PassThru
|
| if ($extractProc.ExitCode -ne 0) {
|
| throw "PortableGit extraction failed (exit code $($extractProc.ExitCode))"
|
| }
|
| }
|
| Remove-Item -Force $tmpFile -ErrorAction SilentlyContinue
|
|
|
|
|
|
|
| $gitExe = "$gitDir\cmd\git.exe"
|
| if (-not (Test-Path $gitExe)) {
|
| throw "Git extraction did not produce git.exe at $gitExe"
|
| }
|
|
|
|
|
| $env:Path = "$gitDir\cmd;$env:Path"
|
|
|
|
|
|
|
|
|
| $newPathEntries = @(
|
| "$gitDir\cmd",
|
| "$gitDir\bin",
|
| "$gitDir\usr\bin"
|
| )
|
| $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
|
| $userPathItems = if ($userPath) { $userPath -split ";" } else { @() }
|
| $changed = $false
|
| foreach ($entry in $newPathEntries) {
|
| if ($userPathItems -notcontains $entry) {
|
| $userPathItems += $entry
|
| $changed = $true
|
| }
|
| }
|
| if ($changed) {
|
| [Environment]::SetEnvironmentVariable("Path", ($userPathItems -join ";"), "User")
|
| }
|
|
|
| $version = & $gitExe --version
|
| Write-Success "Git $version installed to $gitDir (portable, user-scoped)"
|
| Set-GitBashEnvVar
|
| if (-not $script:GitBashPath) {
|
| throw "PortableGit extraction did not produce a usable bash.exe"
|
| }
|
| if (-not (Test-GitBashCompatibility -BashPath $script:GitBashPath)) {
|
| if (Test-MandatoryAslrEnabled) {
|
| $script:GitInstallFailureReason = New-GitBashAslrFailureReason -BashPath $script:GitBashPath
|
| } else {
|
| $probeDetail = if ($script:GitBashProbeOutput) { " Probe output: $script:GitBashProbeOutput" } else { "" }
|
| $script:GitInstallFailureReason = "Git Bash at $script:GitBashPath exists but cannot launch required MSYS programs.$probeDetail"
|
| }
|
| throw $script:GitInstallFailureReason
|
| }
|
| Write-Success "Git Bash can launch MSYS programs"
|
| return $true
|
| } catch {
|
| if ($script:GitInstallFailureReason) {
|
| Write-Err $script:GitInstallFailureReason
|
| return $false
|
| }
|
| Write-Err "Could not install portable Git: $_"
|
| Write-Info ""
|
| Write-Info "Fallback: install Git manually from https://git-scm.com/download/win"
|
| Write-Info "then re-run this installer. Hermes needs Git Bash on Windows to run"
|
| Write-Info "shell commands (same as Claude Code and other coding agents)."
|
| return $false
|
| }
|
| }
|
|
|
| function Set-GitBashEnvVar {
|
| |
| |
| |
| |
| |
|
|
| $script:GitBashPath = $null
|
| $candidates = @()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $candidates += "$HermesHome\git\bin\bash.exe"
|
| $candidates += "$HermesHome\git\usr\bin\bash.exe"
|
|
|
|
|
| $gitCmd = Get-Command git -ErrorAction SilentlyContinue
|
| if ($gitCmd) {
|
| $gitExe = $gitCmd.Source
|
|
|
|
|
| $gitRoot = Split-Path (Split-Path $gitExe -Parent) -Parent
|
| $candidates += "$gitRoot\bin\bash.exe"
|
| $candidates += "$gitRoot\usr\bin\bash.exe"
|
| }
|
|
|
|
|
|
|
|
|
| $candidates += "${env:ProgramFiles}\Git\bin\bash.exe"
|
| $pf86 = [Environment]::GetEnvironmentVariable("ProgramFiles(x86)")
|
| if ($pf86) { $candidates += "$pf86\Git\bin\bash.exe" }
|
| $candidates += "${env:LocalAppData}\Programs\Git\bin\bash.exe"
|
|
|
| foreach ($candidate in $candidates) {
|
| if ($candidate -and (Test-Path $candidate)) {
|
| [Environment]::SetEnvironmentVariable("HERMES_GIT_BASH_PATH", $candidate, "User")
|
| $env:HERMES_GIT_BASH_PATH = $candidate
|
| $script:GitBashPath = $candidate
|
| Write-Info "Set HERMES_GIT_BASH_PATH=$candidate"
|
| return
|
| }
|
| }
|
|
|
| Write-Warn "Could not locate bash.exe -- Hermes may not find Git Bash."
|
| Write-Info "If needed, set HERMES_GIT_BASH_PATH manually to your bash.exe path."
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Test-NodeVersionOk {
|
| param([string]$Version)
|
| if ($Version -match '-') { return $false }
|
| try {
|
| $v = [version]($Version -replace '^v', '')
|
| } catch {
|
| return $false
|
| }
|
| if ($v.Major -eq 22) { return ($v.Minor -ge 22) }
|
| if ($v.Major -eq 24) { return ($v.Minor -ge 11) }
|
| return ($v.Major -ge 26)
|
| }
|
|
|
|
|
|
|
|
|
| function Test-SystemNodeReady {
|
| if (-not (Get-Command node -ErrorAction SilentlyContinue)) { return $false }
|
|
|
| $version = node --version
|
| if (Test-NodeVersionOk $version) {
|
| Ensure-NodeExeOnPath | Out-Null
|
| } else {
|
| Write-Warn "Node.js $version is unsupported (Hermes requires Node 22.22+, 24.11+, or 26+)"
|
| return $false
|
| }
|
|
|
| $npmRange = Get-NpmRange
|
| $npmCmd = Get-Command npm.cmd -ErrorAction SilentlyContinue
|
| if (-not $npmCmd) {
|
| $npmCmd = Get-Command npm -ErrorAction SilentlyContinue
|
| }
|
|
|
| $npmVersion = $null
|
| if ($npmCmd) {
|
| try {
|
| $npmVersion = (& $npmCmd --version 2>$null | Select-Object -First 1)
|
| } catch { }
|
| }
|
|
|
| if ($npmVersion -and (Test-NpmVersionOk $npmVersion $npmRange)) {
|
| Write-Success "Node.js $version with npm $npmVersion found"
|
| return $true
|
| }
|
|
|
| if ($npmVersion) {
|
| Write-Warn "Node.js $version uses npm $npmVersion, which does not satisfy Hermes requirement $npmRange"
|
| } else {
|
| Write-Warn "Node.js $version was found, but npm is missing or could not report its version"
|
| }
|
| return $false
|
| }
|
|
|
| function Test-Node {
|
| Write-Info "Checking Node.js (for browser tools)..."
|
|
|
| if (Test-SystemNodeReady) {
|
| $script:HasNode = $true
|
| return $true
|
| }
|
|
|
| Write-Info "Using a Hermes-managed Node.js installation instead..."
|
|
|
|
|
| $managedNode = "$HermesHome\node\node.exe"
|
| if ((Test-Path $managedNode) -and (Test-NodeVersionOk (& $managedNode --version))) {
|
| $version = & $managedNode --version
|
| $env:Path = "$HermesHome\node;$env:Path"
|
| Set-ManagedNodeFirstOnUserPath "$HermesHome\node"
|
| Write-Success "Node.js $version found (Hermes-managed)"
|
|
|
|
|
|
|
| Update-ManagedNpm "$HermesHome\node" | Out-Null
|
| $script:HasNode = $true
|
| return $true
|
| }
|
|
|
| Write-Info "Installing Hermes-managed Node.js $NodeVersion LTS..."
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "Downloading portable Node.js $NodeVersion to $HermesHome\node\ ..."
|
| Write-Info "(no admin rights required; isolated from any system Node install)"
|
| try {
|
| $arch = Get-WindowsArch
|
| $indexUrl = "https://nodejs.org/dist/latest-v${NodeVersion}.x/"
|
| $indexPage = Invoke-WebRequest -Uri $indexUrl -UseBasicParsing
|
| $zipName = ($indexPage.Content | Select-String -Pattern "node-v${NodeVersion}\.\d+\.\d+-win-${arch}\.zip" -AllMatches).Matches[0].Value
|
|
|
| if ($zipName) {
|
| $downloadUrl = "${indexUrl}${zipName}"
|
| $tmpZip = "$env:TEMP\$zipName"
|
| $tmpDir = "$env:TEMP\hermes-node-extract"
|
|
|
| Invoke-WebRequest -Uri $downloadUrl -OutFile $tmpZip -UseBasicParsing
|
| if (Test-Path $tmpDir) { Remove-Item -Recurse -Force $tmpDir }
|
| Expand-Archive -Path $tmpZip -DestinationPath $tmpDir -Force
|
|
|
| $extractedDir = Get-ChildItem $tmpDir -Directory | Select-Object -First 1
|
| if ($extractedDir) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Get-ChildItem "$HermesHome" -Directory -Filter "node.old-*" -ErrorAction SilentlyContinue |
|
| Where-Object { $_.LastWriteTime -lt (Get-Date).AddMinutes(-10) } |
|
| Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
|
| Get-ChildItem "$HermesHome" -Directory -Filter "node.new-*" -ErrorAction SilentlyContinue |
|
| Where-Object { $_.LastWriteTime -lt (Get-Date).AddMinutes(-10) } |
|
| Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
|
| $stamp = [Guid]::NewGuid().ToString("N")
|
| $staged = "$HermesHome\node.new-$stamp"
|
| $backup = "$HermesHome\node.old-$stamp"
|
|
|
|
|
|
|
|
|
| try {
|
| Move-Item $extractedDir.FullName $staged -ErrorAction Stop
|
| } catch {
|
| Write-Warn "Failed to stage the new Node.js tree; aborting the Node upgrade."
|
| Remove-Item -Recurse -Force $tmpDir -ErrorAction SilentlyContinue
|
| Remove-Item -Force $tmpZip -ErrorAction SilentlyContinue
|
| return $false
|
| }
|
| if (Test-Path "$HermesHome\node") {
|
| try {
|
| Rename-Item "$HermesHome\node" $backup -ErrorAction Stop
|
| } catch {
|
| Write-Warn "Hermes-managed Node.js is in use by a running app; deferring its upgrade. Close the app and re-run the update."
|
| Remove-Item -Recurse -Force $staged -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $tmpDir -ErrorAction SilentlyContinue
|
| Remove-Item -Force $tmpZip -ErrorAction SilentlyContinue
|
| return $false
|
| }
|
|
|
|
|
|
|
|
|
| try {
|
| (Get-Item $backup).LastWriteTime = Get-Date
|
| } catch { }
|
| try {
|
| Rename-Item $staged "$HermesHome\node" -ErrorAction Stop
|
| } catch {
|
|
|
|
|
|
|
| Rename-Item $backup "$HermesHome\node" -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $staged -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $tmpDir -ErrorAction SilentlyContinue
|
| Remove-Item -Force $tmpZip -ErrorAction SilentlyContinue
|
| return $false
|
| }
|
| Remove-Item -Recurse -Force $backup -ErrorAction SilentlyContinue
|
| } else {
|
| try {
|
| Rename-Item $staged "$HermesHome\node" -ErrorAction Stop
|
| } catch {
|
| Remove-Item -Recurse -Force $staged -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $tmpDir -ErrorAction SilentlyContinue
|
| Remove-Item -Force $tmpZip -ErrorAction SilentlyContinue
|
| return $false
|
| }
|
| }
|
|
|
|
|
| $env:Path = "$HermesHome\node;$env:Path"
|
|
|
|
|
|
|
|
|
|
|
|
|
| Set-ManagedNodeFirstOnUserPath "$HermesHome\node"
|
|
|
| $version = & "$HermesHome\node\node.exe" --version
|
| Write-Success "Node.js $version installed to $HermesHome\node\ (portable, user-scoped)"
|
|
|
| Update-ManagedNpm "$HermesHome\node" | Out-Null
|
| $script:HasNode = $true
|
|
|
| Remove-Item -Force $tmpZip -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $tmpDir -ErrorAction SilentlyContinue
|
| return $true
|
| }
|
| }
|
| } catch {
|
| Write-Warn "Portable Node.js download failed: $_"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (Get-Command winget -ErrorAction SilentlyContinue) {
|
| Write-Info "Falling back to winget (may prompt UAC -- check your taskbar for a flashing icon)..."
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
|
|
|
|
|
|
|
|
| $ErrorActionPreference = "Continue"
|
|
|
|
|
|
|
|
|
|
|
| $wingetArgs = @(
|
| 'install','OpenJS.NodeJS','--silent',
|
| '--accept-package-agreements','--accept-source-agreements'
|
| )
|
| if ((Get-WindowsArch) -eq 'arm64') {
|
| $wingetArgs += @('--architecture','arm64')
|
| }
|
| winget @wingetArgs 2>&1 | Out-Null
|
| $ErrorActionPreference = $prevEAP
|
|
|
| $env:Path = [Environment]::GetEnvironmentVariable("Path", "User") + ";" + [Environment]::GetEnvironmentVariable("Path", "Machine")
|
| if (Test-SystemNodeReady) {
|
| $script:HasNode = $true
|
| return $true
|
| }
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| }
|
| }
|
|
|
|
|
| Write-Info "Install manually: https://nodejs.org/en/download/"
|
| $script:HasNode = $false
|
| return $true
|
| }
|
|
|
| function Update-ProcessPathForPackages {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $candidates = @()
|
| $candidates += $env:Path
|
| $candidates += [Environment]::GetEnvironmentVariable("Path", "User")
|
| $candidates += [Environment]::GetEnvironmentVariable("Path", "Machine")
|
| $wingetLinks = Join-Path $env:LOCALAPPDATA "Microsoft\WinGet\Links"
|
| if (Test-Path $wingetLinks) {
|
| $candidates += $wingetLinks
|
| }
|
| $seen = New-Object System.Collections.Generic.HashSet[string] ([StringComparer]::OrdinalIgnoreCase)
|
| $ordered = New-Object System.Collections.Generic.List[string]
|
| foreach ($chunk in $candidates) {
|
| if ([string]::IsNullOrEmpty($chunk)) { continue }
|
| foreach ($entry in $chunk.Split(';')) {
|
| $trimmed = $entry.Trim()
|
| if ($trimmed -and $seen.Add($trimmed)) {
|
| $ordered.Add($trimmed)
|
| }
|
| }
|
| }
|
| $env:Path = [string]::Join(';', $ordered)
|
| }
|
|
|
| function Install-SystemPackages {
|
| $script:HasRipgrep = $false
|
| $script:HasFfmpeg = $false
|
| $needRipgrep = $false
|
| $needFfmpeg = $false
|
|
|
| Write-Info "Checking ripgrep (fast file search)..."
|
| if (Get-Command rg -ErrorAction SilentlyContinue) {
|
| $version = rg --version | Select-Object -First 1
|
| Write-Success "$version found"
|
| $script:HasRipgrep = $true
|
| } else {
|
| $needRipgrep = $true
|
| }
|
|
|
| Write-Info "Checking ffmpeg (TTS voice messages)..."
|
| if (Get-Command ffmpeg -ErrorAction SilentlyContinue) {
|
| Write-Success "ffmpeg found"
|
| $script:HasFfmpeg = $true
|
| } else {
|
| $needFfmpeg = $true
|
| }
|
|
|
| if (-not $needRipgrep -and -not $needFfmpeg) { return }
|
|
|
|
|
| $descParts = @()
|
| $wingetPkgs = @()
|
| $chocoPkgs = @()
|
| $scoopPkgs = @()
|
|
|
| if ($needRipgrep) {
|
| $descParts += "ripgrep for faster file search"
|
| $wingetPkgs += "BurntSushi.ripgrep.MSVC"
|
| $chocoPkgs += "ripgrep"
|
| $scoopPkgs += "ripgrep"
|
| }
|
| if ($needFfmpeg) {
|
| $descParts += "ffmpeg for TTS voice messages"
|
| $wingetPkgs += "Gyan.FFmpeg"
|
| $chocoPkgs += "ffmpeg"
|
| $scoopPkgs += "ffmpeg"
|
| }
|
|
|
| $description = $descParts -join " and "
|
| $hasWinget = Get-Command winget -ErrorAction SilentlyContinue
|
| $hasChoco = Get-Command choco -ErrorAction SilentlyContinue
|
| $hasScoop = Get-Command scoop -ErrorAction SilentlyContinue
|
|
|
|
|
| if ($hasWinget) {
|
| Write-Info "Installing $description via winget..."
|
|
|
|
|
|
|
|
|
| $pkgLogs = @{}
|
| foreach ($pkg in $wingetPkgs) {
|
| $log = "$env:TEMP\hermes-winget-$($pkg -replace '[^A-Za-z0-9]','_')-$(Get-Random).log"
|
| $pkgLogs[$pkg] = $log
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| $output = winget install --exact --id $pkg --source winget --silent `
|
| --accept-package-agreements --accept-source-agreements 2>&1
|
| $code = $LASTEXITCODE
|
| $output | Out-File -FilePath $log -Encoding utf8
|
| "winget exit: $code" | Out-File -FilePath $log -Encoding utf8 -Append
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($code -eq -1978335189) {
|
| "-> already-installed/no-upgrade; retrying with --force" | Out-File -FilePath $log -Encoding utf8 -Append
|
| $output = winget install --exact --id $pkg --source winget --silent --force `
|
| --accept-package-agreements --accept-source-agreements 2>&1
|
| $output | Out-File -FilePath $log -Encoding utf8 -Append
|
| "winget exit (force): $LASTEXITCODE" | Out-File -FilePath $log -Encoding utf8 -Append
|
| }
|
| } catch {
|
| $_ | Out-File -FilePath $log -Encoding utf8 -Append
|
| "winget exit: <exception>" | Out-File -FilePath $log -Encoding utf8 -Append
|
| }
|
| }
|
|
|
|
|
|
|
| Update-ProcessPathForPackages
|
| if ($needRipgrep -and (Get-Command rg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ripgrep installed"
|
| $script:HasRipgrep = $true
|
| $needRipgrep = $false
|
| Remove-Item -Path $pkgLogs["BurntSushi.ripgrep.MSVC"] -ErrorAction SilentlyContinue
|
| } elseif ($pkgLogs.ContainsKey("BurntSushi.ripgrep.MSVC")) {
|
| Write-Warn "winget could not install ripgrep; details: $($pkgLogs['BurntSushi.ripgrep.MSVC'])"
|
| }
|
| if ($needFfmpeg -and (Get-Command ffmpeg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ffmpeg installed"
|
| $script:HasFfmpeg = $true
|
| $needFfmpeg = $false
|
| Remove-Item -Path $pkgLogs["Gyan.FFmpeg"] -ErrorAction SilentlyContinue
|
| } elseif ($pkgLogs.ContainsKey("Gyan.FFmpeg")) {
|
| Write-Warn "winget could not install ffmpeg; details: $($pkgLogs['Gyan.FFmpeg'])"
|
| }
|
| if (-not $needRipgrep -and -not $needFfmpeg) { return }
|
| }
|
|
|
|
|
| if ($hasChoco -and ($needRipgrep -or $needFfmpeg)) {
|
| Write-Info "Trying Chocolatey..."
|
| foreach ($pkg in $chocoPkgs) {
|
| try { choco install $pkg -y 2>&1 | Out-Null } catch { }
|
| }
|
| Update-ProcessPathForPackages
|
| if ($needRipgrep -and (Get-Command rg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ripgrep installed via chocolatey"
|
| $script:HasRipgrep = $true
|
| $needRipgrep = $false
|
| }
|
| if ($needFfmpeg -and (Get-Command ffmpeg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ffmpeg installed via chocolatey"
|
| $script:HasFfmpeg = $true
|
| $needFfmpeg = $false
|
| }
|
| }
|
|
|
|
|
| if ($hasScoop -and ($needRipgrep -or $needFfmpeg)) {
|
| Write-Info "Trying Scoop..."
|
| foreach ($pkg in $scoopPkgs) {
|
| try { scoop install $pkg 2>&1 | Out-Null } catch { }
|
| }
|
| Update-ProcessPathForPackages
|
| if ($needRipgrep -and (Get-Command rg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ripgrep installed via scoop"
|
| $script:HasRipgrep = $true
|
| $needRipgrep = $false
|
| }
|
| if ($needFfmpeg -and (Get-Command ffmpeg -ErrorAction SilentlyContinue)) {
|
| Write-Success "ffmpeg installed via scoop"
|
| $script:HasFfmpeg = $true
|
| $needFfmpeg = $false
|
| }
|
| }
|
|
|
|
|
| if ($needRipgrep) {
|
| Write-Warn "ripgrep not installed (file search will use findstr fallback)"
|
| Write-Info " winget install BurntSushi.ripgrep.MSVC"
|
| }
|
| if ($needFfmpeg) {
|
| Write-Warn "ffmpeg not installed (TTS voice messages will be limited)"
|
| Write-Info " winget install Gyan.FFmpeg"
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function Install-Repository {
|
| Write-Info "Installing to $InstallDir..."
|
|
|
| $didUpdate = $false
|
|
|
| if (Test-Path $InstallDir) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $repoValid = $false
|
| if (Test-Path "$InstallDir\.git") {
|
| Push-Location $InstallDir
|
| try {
|
|
|
|
|
| $global:LASTEXITCODE = 0
|
| $revParseOut = & git -c windows.appendAtomically=false rev-parse --is-inside-work-tree 2>&1
|
| $revParseOk = ($LASTEXITCODE -eq 0) -and ($revParseOut -match "true")
|
|
|
| $global:LASTEXITCODE = 0
|
| $null = & git -c windows.appendAtomically=false status --short 2>&1
|
| $statusOk = ($LASTEXITCODE -eq 0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $global:LASTEXITCODE = 0
|
| $null = & git -c windows.appendAtomically=false rev-parse --verify HEAD 2>&1
|
| $hasCommit = ($LASTEXITCODE -eq 0)
|
|
|
| if ($revParseOk -and $statusOk -and $hasCommit) {
|
| $repoValid = $true
|
| }
|
| } catch {}
|
| Pop-Location
|
| }
|
|
|
| if ($repoValid) {
|
| Write-Info "Existing installation found, updating..."
|
| Push-Location $InstallDir
|
|
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| $autostashRef = ""
|
| try {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| git -c windows.appendAtomically=false config core.autocrlf false 2>$null
|
| Discard-LockfileChurn $InstallDir
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $statusOut = git -c windows.appendAtomically=false status --porcelain 2>$null
|
| if (-not [string]::IsNullOrWhiteSpace(($statusOut -join "`n"))) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $unmergedOut = git -c windows.appendAtomically=false ls-files --unmerged 2>$null
|
| if (-not [string]::IsNullOrWhiteSpace(($unmergedOut -join "`n"))) {
|
| Write-Info "Clearing unmerged index entries from a previous conflict..."
|
| git -c windows.appendAtomically=false reset -q 2>$null
|
| }
|
| $stashName = "hermes-install-autostash-" + (Get-Date -Format "yyyyMMdd-HHmmss")
|
| Write-Info "Local changes detected, stashing before update..."
|
| git -c windows.appendAtomically=false stash push --include-untracked -m "$stashName"
|
| if ($LASTEXITCODE -eq 0) { $autostashRef = "stash@{0}" }
|
| }
|
| git -c windows.appendAtomically=false fetch origin $Branch
|
| if ($LASTEXITCODE -ne 0) { throw "git fetch failed (exit $LASTEXITCODE)" }
|
|
|
|
|
|
|
| if ($Commit) {
|
|
|
|
|
| git -c windows.appendAtomically=false fetch origin $Commit
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $skipRollback = $false
|
| if (-not $ForceCommit) {
|
| git -c windows.appendAtomically=false merge-base --is-ancestor $Commit HEAD 2>$null
|
| $isAncestor = ($LASTEXITCODE -eq 0)
|
| $pinnedSha = (& git -c windows.appendAtomically=false rev-parse "$Commit^{commit}" 2>$null)
|
| $headSha = (& git -c windows.appendAtomically=false rev-parse HEAD 2>$null)
|
| $skipRollback = $isAncestor -and ($pinnedSha -ne $headSha)
|
| }
|
| if ($skipRollback) {
|
| Write-Warn "Ignoring -Commit $Commit`: the checkout is already newer."
|
| Write-Warn "Pinning to it would roll this install back. Pass -ForceCommit to override."
|
| } else {
|
| git -c windows.appendAtomically=false checkout --detach $Commit
|
| if ($LASTEXITCODE -ne 0) { throw "git checkout $Commit failed (exit $LASTEXITCODE)" }
|
| }
|
| } elseif ($Tag) {
|
| git -c windows.appendAtomically=false fetch origin "refs/tags/${Tag}:refs/tags/${Tag}"
|
| git -c windows.appendAtomically=false checkout --detach "refs/tags/$Tag"
|
| if ($LASTEXITCODE -ne 0) { throw "git checkout tag $Tag failed (exit $LASTEXITCODE)" }
|
| } else {
|
| git -c windows.appendAtomically=false checkout $Branch
|
| if ($LASTEXITCODE -ne 0) { throw "git checkout $Branch failed (exit $LASTEXITCODE)" }
|
|
|
|
|
|
|
|
|
| git -c windows.appendAtomically=false pull --ff-only origin $Branch
|
| if ($LASTEXITCODE -ne 0) {
|
| Write-Warn "Fast-forward not possible; resetting managed install to origin/$Branch..."
|
| git -c windows.appendAtomically=false reset --hard "origin/$Branch"
|
| if ($LASTEXITCODE -ne 0) { throw "git reset --hard origin/$Branch failed (exit $LASTEXITCODE)" }
|
| }
|
| }
|
|
|
| if ($autostashRef) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $restoreNow = $true
|
| $hasConsole = $false
|
| try {
|
| $hasConsole = (
|
| [Environment]::UserInteractive `
|
| -and (-not [Console]::IsInputRedirected) `
|
| -and (-not [Console]::IsOutputRedirected) `
|
| -and ($Host.Name -eq "ConsoleHost")
|
| )
|
| } catch { $hasConsole = $false }
|
| if ($hasConsole) {
|
| Write-Warn "Local changes were stashed before updating."
|
| Write-Warn "Restoring them may reapply local customizations onto the updated codebase."
|
| $restoreAnswer = Read-Host "Restore local changes now? [Y/n]"
|
| if ($restoreAnswer -match '^(n|no)$') { $restoreNow = $false }
|
| }
|
|
|
| if ($restoreNow) {
|
| Write-Info "Restoring local changes..."
|
| $restoreOutput = @(git -c windows.appendAtomically=false stash apply $autostashRef 2>&1)
|
| $restoreExit = $LASTEXITCODE
|
| $conflictedFiles = @(
|
| git -c windows.appendAtomically=false diff --name-only --diff-filter=U 2>$null
|
| ) | Where-Object { $_ -and $_.ToString().Trim() }
|
| if (($restoreExit -eq 0) -and ($conflictedFiles.Count -eq 0)) {
|
| git -c windows.appendAtomically=false stash drop $autostashRef 2>$null
|
| Write-Warn "Local changes were restored on top of the updated codebase."
|
| Write-Warn "Review git diff / git status if Hermes behaves unexpectedly."
|
| } else {
|
| Write-Err "Update pulled new code, but restoring local changes hit conflicts."
|
| foreach ($line in $restoreOutput) {
|
| if ($line -and $line.ToString().Trim()) {
|
| Write-Host $line
|
| }
|
| }
|
| if ($conflictedFiles.Count -gt 0) {
|
| Write-Host ""
|
| Write-Host "Conflicted files:"
|
| foreach ($file in $conflictedFiles) {
|
| Write-Host " - $file"
|
| }
|
| }
|
| Write-Host ""
|
| Write-Info "Your stashed changes are preserved -- nothing is lost."
|
| Write-Info " Stash ref: $autostashRef"
|
| git -c windows.appendAtomically=false reset --hard HEAD 2>$null | Out-Null
|
| Write-Info "Working tree reset to clean state."
|
| Write-Info "Restore your changes later with: git stash apply $autostashRef"
|
| }
|
| } else {
|
| Write-Info "Skipped restoring local changes."
|
| Write-Info "Your changes are still preserved in git stash."
|
| Write-Info "Restore manually with: git stash apply $autostashRef"
|
| }
|
| $autostashRef = ""
|
| }
|
| } finally {
|
| if ($autostashRef) {
|
|
|
|
|
|
|
| Write-Warn "Update did not complete. Your local changes are preserved in git stash."
|
| Write-Info "Restore manually with: git stash apply $autostashRef"
|
| }
|
| $ErrorActionPreference = $prevEAP
|
| Pop-Location
|
| }
|
| $didUpdate = $true
|
| } else {
|
|
|
|
|
|
|
|
|
|
|
|
|
| $backupDir = "$InstallDir.broken-" + (Get-Date -Format "yyyyMMdd-HHmmss")
|
| Write-Warn "Existing directory at $InstallDir is not a valid git repo."
|
| Write-Warn "Moving it aside to $backupDir before re-cloning."
|
| try {
|
| Move-Item -LiteralPath $InstallDir -Destination $backupDir -ErrorAction Stop
|
| } catch {
|
| Write-Err "Could not move $InstallDir aside : $_"
|
| Write-Info "Close any programs that might be using files in $InstallDir (editors,"
|
| Write-Info "terminals, running hermes processes) and try again."
|
| throw
|
| }
|
| }
|
| }
|
|
|
| if (-not $didUpdate) {
|
| $cloneSuccess = $false
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "Configuring git for Windows compatibility..."
|
| $env:GIT_CONFIG_COUNT = "1"
|
| $env:GIT_CONFIG_KEY_0 = "windows.appendAtomically"
|
| $env:GIT_CONFIG_VALUE_0 = "false"
|
| git config --global windows.appendAtomically false 2>$null
|
|
|
|
|
| Write-Info "Trying SSH clone..."
|
| $env:GIT_SSH_COMMAND = "ssh -o BatchMode=yes -o ConnectTimeout=5"
|
| try {
|
| Invoke-NativeWithRelaxedErrorAction { git -c windows.appendAtomically=false clone --depth 1 --branch $Branch $RepoUrlSsh $InstallDir }
|
| if ($LASTEXITCODE -eq 0) { $cloneSuccess = $true }
|
| } catch { }
|
| $env:GIT_SSH_COMMAND = $null
|
|
|
| if (-not $cloneSuccess) {
|
| if (Test-Path $InstallDir) { Remove-Item -Recurse -Force $InstallDir -ErrorAction SilentlyContinue }
|
| Write-Info "SSH failed, trying HTTPS..."
|
| try {
|
| Invoke-NativeWithRelaxedErrorAction { git -c windows.appendAtomically=false clone --depth 1 --branch $Branch $RepoUrlHttps $InstallDir }
|
| if ($LASTEXITCODE -eq 0) { $cloneSuccess = $true }
|
| } catch { }
|
| }
|
|
|
|
|
| if (-not $cloneSuccess) {
|
| if (Test-Path $InstallDir) { Remove-Item -Recurse -Force $InstallDir -ErrorAction SilentlyContinue }
|
| Write-Warn "Git clone failed -- downloading ZIP archive instead..."
|
| try {
|
|
|
|
|
|
|
| if ($Commit) {
|
| $zipUrl = "https://github.com/NousResearch/hermes-agent/archive/$Commit.zip"
|
| $zipLabel = $Commit
|
| } elseif ($Tag) {
|
| $zipUrl = "https://github.com/NousResearch/hermes-agent/archive/refs/tags/$Tag.zip"
|
| $zipLabel = $Tag
|
| } else {
|
| $zipUrl = "https://github.com/NousResearch/hermes-agent/archive/refs/heads/$Branch.zip"
|
| $zipLabel = $Branch
|
| }
|
| $zipPath = "$env:TEMP\hermes-agent-$zipLabel.zip"
|
| $extractPath = "$env:TEMP\hermes-agent-extract"
|
|
|
| Invoke-WebRequest -Uri $zipUrl -OutFile $zipPath -UseBasicParsing
|
| if (Test-Path $extractPath) { Remove-Item -Recurse -Force $extractPath }
|
| Expand-Archive -Path $zipPath -DestinationPath $extractPath -Force
|
|
|
|
|
| $extractedDir = Get-ChildItem $extractPath -Directory | Select-Object -First 1
|
| if ($extractedDir) {
|
| New-Item -ItemType Directory -Force -Path (Split-Path $InstallDir) -ErrorAction SilentlyContinue | Out-Null
|
| Move-Item $extractedDir.FullName $InstallDir -Force
|
| Write-Success "Downloaded and extracted"
|
|
|
|
|
|
|
|
|
|
|
|
|
| Push-Location $InstallDir
|
| git -c windows.appendAtomically=false init 2>$null
|
| git -c windows.appendAtomically=false config windows.appendAtomically false 2>$null
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| git -c windows.appendAtomically=false config core.autocrlf false 2>$null
|
| git remote add origin $RepoUrlHttps 2>$null
|
| $fetchRef = if ($Commit) { $Commit } elseif ($Tag) { "refs/tags/$Tag" } else { $Branch }
|
| Write-Info "Fetching $fetchRef so the ZIP checkout has a resolvable HEAD..."
|
| $prevZipEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
| git -c windows.appendAtomically=false fetch --depth 1 origin $fetchRef 2>&1 | Out-Null
|
| if ($LASTEXITCODE -eq 0) {
|
| if ($Commit -or $Tag) {
|
| git -c windows.appendAtomically=false checkout -f --detach FETCH_HEAD 2>&1 | Out-Null
|
| } else {
|
| git -c windows.appendAtomically=false checkout -f -B $Branch FETCH_HEAD 2>&1 | Out-Null
|
| }
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "ZIP checkout pinned to $fetchRef"
|
| } else {
|
|
|
| $fetchSha = & git -c windows.appendAtomically=false rev-parse FETCH_HEAD 2>$null
|
| if ($LASTEXITCODE -eq 0 -and $fetchSha) {
|
| if (-not $env:GITHUB_SHA) { $env:GITHUB_SHA = ("$fetchSha").Trim() }
|
| Write-Warn "ZIP checkout failed; seeded GITHUB_SHA from FETCH_HEAD for desktop stamp"
|
| } else {
|
| Write-Warn "ZIP extract succeeded but git checkout failed -- desktop build may need `$env:GITHUB_SHA"
|
| }
|
| }
|
| } else {
|
| Write-Warn "ZIP extract succeeded but git fetch of $fetchRef failed -- desktop build may need `$env:GITHUB_SHA"
|
| }
|
| } finally {
|
| $ErrorActionPreference = $prevZipEAP
|
| }
|
| Pop-Location
|
| Write-Success "Git repo initialized for future updates"
|
|
|
| $cloneSuccess = $true
|
| }
|
|
|
|
|
| Remove-Item -Force $zipPath -ErrorAction SilentlyContinue
|
| Remove-Item -Recurse -Force $extractPath -ErrorAction SilentlyContinue
|
| } catch {
|
| Write-Err "ZIP download also failed: $_"
|
| }
|
| }
|
|
|
| if (-not $cloneSuccess) {
|
| throw "Failed to download repository (tried git clone SSH, HTTPS, and ZIP)"
|
| }
|
| }
|
|
|
|
|
| Push-Location $InstallDir
|
| git -c windows.appendAtomically=false config windows.appendAtomically false 2>$null
|
|
|
|
|
|
|
|
|
| git -c windows.appendAtomically=false config core.autocrlf false 2>$null
|
|
|
|
|
|
|
|
|
|
|
| if (-not $didUpdate) {
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
| if ($Commit) {
|
| Write-Info "Pinning to commit $Commit..."
|
| git -c windows.appendAtomically=false fetch origin $Commit
|
| git -c windows.appendAtomically=false checkout --detach $Commit
|
| if ($LASTEXITCODE -ne 0) {
|
| throw "git checkout $Commit failed (exit $LASTEXITCODE)"
|
| }
|
| } elseif ($Tag) {
|
| Write-Info "Pinning to tag $Tag..."
|
| git -c windows.appendAtomically=false fetch origin "refs/tags/${Tag}:refs/tags/${Tag}"
|
| git -c windows.appendAtomically=false checkout --detach "refs/tags/$Tag"
|
| if ($LASTEXITCODE -ne 0) {
|
| throw "git checkout tag $Tag failed (exit $LASTEXITCODE)"
|
| }
|
| }
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| }
|
| }
|
|
|
| Write-Success "Repository ready"
|
| }
|
|
|
| function Install-Venv {
|
| if ($NoVenv) {
|
| Write-Info "Skipping virtual environment (-NoVenv)"
|
| return
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $resolvedPython = Resolve-AvailablePythonVersion
|
| if (-not $resolvedPython) {
|
| throw "Hermes-managed Python is unavailable. Run install.ps1 -Stage python first."
|
| }
|
|
|
| Write-Info "Creating virtual environment with Python $($resolvedPython.Version)..."
|
|
|
| Push-Location $InstallDir
|
|
|
|
|
|
|
|
|
| $gatewayTasksDisabled = @()
|
| $venvHadExistingVenv = $false
|
| $venvBackupName = $null
|
| $venvParked = $false
|
| try {
|
| if (Test-Path -LiteralPath "venv") {
|
| $venvHadExistingVenv = $true
|
| Write-Info "Virtual environment already exists, recreating..."
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($env:OS -eq "Windows_NT") {
|
| $myPid = $PID
|
| Write-Info "Stopping any running hermes processes before recreating venv..."
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| schtasks /Query /FO CSV 2>$null | ConvertFrom-Csv | Where-Object { $_.TaskName -like '*Hermes_Gateway*' } | ForEach-Object {
|
| $tn = $_.TaskName
|
| if ($_.Status -eq 'Disabled') {
|
| Write-Info " gateway autostart task $tn is already disabled; leaving it that way"
|
| return
|
| }
|
| schtasks /End /TN $tn 2>$null | Out-Null
|
| schtasks /Change /TN $tn /DISABLE 2>$null | Out-Null
|
| $gatewayTasksDisabled += $tn
|
| Write-Info " disabled gateway autostart task $tn for the duration of the install"
|
| }
|
| } catch {
|
| Write-Warn "Could not enumerate gateway scheduled tasks: $($_.Exception.Message)"
|
| }
|
|
|
| & taskkill /F /T /IM hermes.exe /FI "PID ne $myPid" 2>$null | Out-Null
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $venvPrefix = [System.IO.Path]::GetFullPath((Join-Path $InstallDir "venv")).TrimEnd('\') + '\'
|
| $cleanPasses = 0
|
| for ($sweep = 0; $sweep -lt 10 -and $cleanPasses -lt 3; $sweep++) {
|
| $found = 0
|
| try {
|
| Get-CimInstance Win32_Process -ErrorAction Stop |
|
| Where-Object { $_.ProcessId -ne $myPid -and $_.ExecutablePath -and $_.ExecutablePath.StartsWith($venvPrefix, [System.StringComparison]::OrdinalIgnoreCase) } |
|
| ForEach-Object {
|
| $found++
|
| $treePid = [string]$_.ProcessId
|
| Write-Info " stopping process tree at PID $treePid ($($_.Name)) running from venv"
|
| & taskkill /F /T /PID $treePid 2>$null | Out-Null
|
| }
|
| } catch {
|
| Write-Warn "Could not enumerate venv processes: $($_.Exception.Message)"
|
| break
|
| }
|
| if ($found -eq 0) { $cleanPasses++ } else { $cleanPasses = 0 }
|
| Start-Sleep -Milliseconds 400
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $venvBackupName = "venv.stale.{0}-{1}" -f (Get-Date -Format "yyyyMMddHHmmss"), ([Guid]::NewGuid().ToString("N"))
|
| try {
|
| Rename-Item -LiteralPath "venv" -NewName $venvBackupName -ErrorAction Stop
|
| $venvParked = $true
|
| } catch {
|
| $renameErr = $_.Exception.Message
|
| throw (
|
| "Could not move the existing venv aside ($renameErr). " +
|
| "A process still has the install directory open (often a non-Hermes " +
|
| "python.exe that resolved into this venv via PATH). Close those " +
|
| "processes and retry - the previous install was left intact."
|
| )
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| $venvProcess = New-Object System.Diagnostics.Process
|
| try {
|
| $venvStartInfo = New-Object System.Diagnostics.ProcessStartInfo
|
| $venvStartInfo.FileName = $UvCmd
|
| $venvStartInfo.Arguments = "venv venv --python `"$($resolvedPython.Path)`" --managed-python --no-python-downloads --no-config"
|
| $venvStartInfo.WorkingDirectory = $InstallDir
|
| $venvStartInfo.UseShellExecute = $false
|
| $venvStartInfo.CreateNoWindow = $true
|
| $venvStartInfo.RedirectStandardOutput = $true
|
| $venvStartInfo.RedirectStandardError = $true
|
| $venvProcess.StartInfo = $venvStartInfo
|
| if (-not $venvProcess.Start()) {
|
| throw "Failed to start uv while creating the virtual environment"
|
| }
|
| $venvStdoutTask = $venvProcess.StandardOutput.ReadToEndAsync()
|
| $venvStderrTask = $venvProcess.StandardError.ReadToEndAsync()
|
| $venvProcess.WaitForExit()
|
| $venvStdout = $venvStdoutTask.Result
|
| $venvStderr = $venvStderrTask.Result
|
| $venvExitCode = $venvProcess.ExitCode
|
| if ($venvStdout) { Write-Host $venvStdout.TrimEnd() }
|
| if ($venvStderr) { Write-Host $venvStderr.TrimEnd() }
|
| } finally {
|
| $venvProcess.Dispose()
|
| }
|
|
|
| if ($venvExitCode -ne 0) {
|
| throw "Failed to create virtual environment (uv venv exited with $venvExitCode)"
|
| }
|
|
|
|
|
|
|
|
|
| $venvPythonExe = Join-Path $InstallDir "venv\Scripts\python.exe"
|
| if (-not (Test-Path -LiteralPath $venvPythonExe -PathType Leaf)) {
|
| throw "uv reported success but venv interpreter is missing at $venvPythonExe"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($venvParked) {
|
| Set-Content -LiteralPath (Join-Path $InstallDir "venv.pending-backup") -Value $venvBackupName -Encoding ascii
|
| Write-Info "Previous venv parked at $venvBackupName until the dependency install is verified"
|
| }
|
|
|
|
|
|
|
|
|
|
|
| Get-ChildItem -Directory -Filter "venv.stale.*" -ErrorAction SilentlyContinue |
|
| Where-Object { $_.Name -ne $venvBackupName } | ForEach-Object {
|
| Remove-Item -Recurse -Force $_.FullName -ErrorAction SilentlyContinue
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $env:UV_PYTHON = $venvPythonExe
|
| } catch {
|
| $originalError = $_
|
| $rollbackError = $null
|
|
|
| if ($venvParked -and $venvBackupName -and (Test-Path -LiteralPath $venvBackupName)) {
|
| try {
|
| if (Test-Path -LiteralPath "venv") {
|
| $failedVenvName = "venv.failed.{0}-{1}" -f (Get-Date -Format "yyyyMMddHHmmss"), ([Guid]::NewGuid().ToString("N"))
|
| Rename-Item -LiteralPath "venv" -NewName $failedVenvName -ErrorAction Stop
|
| Write-Warn "Failed replacement parked at $failedVenvName"
|
| }
|
| Rename-Item -LiteralPath $venvBackupName -NewName "venv" -ErrorAction Stop
|
| Write-Warn "Restored previous virtual environment after failed recreate"
|
| } catch {
|
| $rollbackError = $_.Exception.Message
|
| }
|
|
|
| if ($rollbackError) {
|
| throw "Virtual environment recreate failed: $($originalError.Exception.Message). Rollback failed: $rollbackError. Previous venv remains at $venvBackupName."
|
| }
|
| } elseif (-not $venvHadExistingVenv -and (Test-Path -LiteralPath "venv")) {
|
|
|
|
|
| try {
|
| $failedVenvName = "venv.failed.{0}-{1}" -f (Get-Date -Format "yyyyMMddHHmmss"), ([Guid]::NewGuid().ToString("N"))
|
| Rename-Item -LiteralPath "venv" -NewName $failedVenvName -ErrorAction Stop
|
| Write-Warn "Partial virtual environment parked at $failedVenvName"
|
| } catch {
|
| $rollbackError = $_.Exception.Message
|
| }
|
| if ($rollbackError) {
|
| throw "Virtual environment creation failed: $($originalError.Exception.Message). Could not park partial venv: $rollbackError"
|
| }
|
| }
|
|
|
| throw $originalError
|
| } finally {
|
| Pop-Location
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($gatewayTasksDisabled -and $gatewayTasksDisabled.Count -gt 0) {
|
| foreach ($tn in $gatewayTasksDisabled) {
|
| schtasks /Change /TN $tn /ENABLE 2>$null | Out-Null
|
| }
|
| Write-Info "Re-enabled gateway autostart task(s): $($gatewayTasksDisabled -join ', ')"
|
| }
|
| }
|
|
|
| Write-Success "Virtual environment ready (Python $($resolvedPython.Version))"
|
| }
|
|
|
| function Get-PendingVenvBackup {
|
|
|
|
|
|
|
| $markerPath = Join-Path $InstallDir "venv.pending-backup"
|
| if (-not (Test-Path -LiteralPath $markerPath -PathType Leaf)) { return $null }
|
| $name = (Get-Content -LiteralPath $markerPath -ErrorAction SilentlyContinue | Select-Object -First 1)
|
| if ($name) { $name = $name.Trim() }
|
| if (-not $name -or -not (Test-Path -LiteralPath (Join-Path $InstallDir $name))) {
|
| Remove-Item -LiteralPath $markerPath -Force -ErrorAction SilentlyContinue
|
| return $null
|
| }
|
| return $name
|
| }
|
|
|
| function Complete-VenvTransaction {
|
|
|
|
|
|
|
| $backupName = Get-PendingVenvBackup
|
| if (-not $backupName) { return }
|
| $backupPath = Join-Path $InstallDir $backupName
|
| Remove-Item -LiteralPath $backupPath -Recurse -Force -ErrorAction SilentlyContinue
|
| if (Test-Path -LiteralPath $backupPath) {
|
| Write-Warn "Old venv parked at $backupName (a process still holds files in it); it will be cleaned up on the next install"
|
| }
|
| Remove-Item -LiteralPath (Join-Path $InstallDir "venv.pending-backup") -Force -ErrorAction SilentlyContinue
|
| }
|
|
|
| function Restore-VenvBackup {
|
|
|
|
|
|
|
| $backupName = Get-PendingVenvBackup
|
| if (-not $backupName) { return }
|
| try {
|
| if (Test-Path -LiteralPath (Join-Path $InstallDir "venv")) {
|
| $failedVenvName = "venv.failed.{0}-{1}" -f (Get-Date -Format "yyyyMMddHHmmss"), ([Guid]::NewGuid().ToString("N"))
|
| Rename-Item -LiteralPath (Join-Path $InstallDir "venv") -NewName $failedVenvName -ErrorAction Stop
|
| Write-Warn "Failed replacement parked at $failedVenvName"
|
| }
|
| Rename-Item -LiteralPath (Join-Path $InstallDir $backupName) -NewName "venv" -ErrorAction Stop
|
| Remove-Item -LiteralPath (Join-Path $InstallDir "venv.pending-backup") -Force -ErrorAction SilentlyContinue
|
| Write-Warn "Restored previous virtual environment after failed dependency install"
|
| } catch {
|
| Write-Warn "Could not restore previous venv (still parked at $backupName): $($_.Exception.Message)"
|
| }
|
| }
|
|
|
| function Install-Dependencies {
|
| Write-Info "Installing dependencies..."
|
|
|
| Push-Location $InstallDir
|
|
|
| if (-not $NoVenv) {
|
|
|
| $env:VIRTUAL_ENV = "$InstallDir\venv"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not $NoVenv) {
|
| $venvPythonExe = Join-Path $InstallDir "venv\Scripts\python.exe"
|
| if (Test-Path $venvPythonExe) {
|
| $env:UV_PYTHON = $venvPythonExe
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| if (Test-Path "uv.lock") {
|
| Write-Info "Trying tier: hash-verified (uv.lock) ..."
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $env:UV_PROJECT_ENVIRONMENT = "$InstallDir\venv"
|
| Invoke-NativeWithRelaxedErrorAction { & $UvCmd sync --extra all --locked }
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "Main package installed (hash-verified via uv.lock)"
|
| $script:InstalledTier = "hash-verified (uv.lock)"
|
|
|
|
|
| $skipPipFallback = $true
|
| } else {
|
| Write-Warn "uv.lock sync failed (lockfile may be stale), falling back to PyPI resolve..."
|
| $skipPipFallback = $false
|
| }
|
| } else {
|
| Write-Info "uv.lock not found -- falling back to PyPI resolve (no hash verification)"
|
| $skipPipFallback = $false
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $brokenExtras = @()
|
|
|
|
|
|
|
| $pythonExeForParse = if (-not $NoVenv) { "$InstallDir\venv\Scripts\python.exe" } else { (& $UvCmd python find $PythonVersion) }
|
| $allExtras = @()
|
| if (Test-Path $pythonExeForParse) {
|
| $parsed = & $pythonExeForParse -c @"
|
| import re, sys, tomllib
|
| try:
|
| with open('pyproject.toml', 'rb') as fh:
|
| data = tomllib.load(fh)
|
| specs = data['project']['optional-dependencies']['all']
|
| out = []
|
| for s in specs:
|
| m = re.search(r'hermes-agent\[([\w-]+)\]', s)
|
| if m: out.append(m.group(1))
|
| print(','.join(out))
|
| except Exception:
|
| sys.exit(1)
|
| "@ 2>$null
|
| if ($LASTEXITCODE -eq 0 -and $parsed) {
|
| $allExtras = $parsed.Trim().Split(',')
|
| }
|
| }
|
| if (-not $allExtras -or $allExtras.Count -eq 0) {
|
| Write-Warn "Could not parse [all] from pyproject.toml; Tier 2 will be a no-op."
|
| $safeAll = "all"
|
| } else {
|
| $safeAll = ($allExtras | Where-Object { $brokenExtras -notcontains $_ }) -join ","
|
| }
|
| $brokenLabel = if ($brokenExtras) { ($brokenExtras -join ", ") } else { "none" }
|
|
|
| $installTiers = @(
|
| @{ Name = "all"; Spec = ".[all]" },
|
| @{ Name = "all minus known-broken ($brokenLabel)"; Spec = ".[$safeAll]" },
|
| @{ Name = "core only (no extras)"; Spec = "." }
|
| )
|
| $installed = $skipPipFallback
|
| if (-not $skipPipFallback) {
|
| foreach ($tier in $installTiers) {
|
| Write-Info "Trying tier: $($tier.Name) ..."
|
| Invoke-NativeWithRelaxedErrorAction { & $UvCmd pip install -e $tier.Spec }
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "Main package installed ($($tier.Name))"
|
| $script:InstalledTier = $tier.Name
|
| $installed = $true
|
| break
|
| }
|
| Write-Warn "Tier '$($tier.Name)' failed (exit $LASTEXITCODE). Trying next tier..."
|
| }
|
| }
|
| if (-not $installed) {
|
| throw "Failed to install hermes-agent package even with no extras. Inspect the uv pip install output above."
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not $NoVenv) {
|
| $venvPython = "$InstallDir\venv\Scripts\python.exe"
|
| if (-not (Test-Path $venvPython)) {
|
| throw "Install reported success but $venvPython does not exist. The dependency sync likely landed in a sibling .venv\ directory. Re-run the installer; if it persists, close Hermes processes and preserve existing venv directories before retrying. Do not delete venv in place."
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| & $venvPython -c "import dotenv, openai, rich, prompt_toolkit" 2>&1 | Out-Null
|
| $importExitCode = $LASTEXITCODE
|
| $ErrorActionPreference = $prevEAP
|
| if ($importExitCode -ne 0) {
|
| $sibling = "$InstallDir\.venv"
|
| $hint = if (Test-Path $sibling) {
|
| "Detected sibling .venv\ at $sibling -- uv synced there instead of venv\. Close Hermes processes, preserve the existing venv, and rerun the installer so the transactional recovery path can move directories safely."
|
| } else {
|
| "Recover with: cd '$InstallDir'; `$env:UV_PROJECT_ENVIRONMENT='$InstallDir\venv'; uv sync --extra all --locked"
|
| }
|
| throw "Baseline imports failed in $InstallDir\venv (dotenv/openai/rich/prompt_toolkit). The install completed but dependencies are not in the venv. $hint"
|
| }
|
| Write-Success "Baseline imports verified in venv"
|
| }
|
|
|
|
|
|
|
|
|
| Complete-VenvTransaction
|
| } catch {
|
|
|
|
|
|
|
| Restore-VenvBackup
|
| Pop-Location
|
| throw
|
| }
|
|
|
| if (-not $NoVenv) {
|
|
|
|
|
|
|
|
|
| $scriptsDir = Join-Path $InstallDir "venv\Scripts"
|
| $pythonExe = Join-Path $scriptsDir "python.exe"
|
| if ((Test-Path $scriptsDir) -and (Test-Path $pythonExe)) {
|
| $scriptNames = & $pythonExe -c @"
|
| import tomllib
|
| with open('pyproject.toml', 'rb') as fh:
|
| scripts = tomllib.load(fh).get('project', {}).get('scripts', {}) or {}
|
| print(','.join(scripts))
|
| "@ 2>$null
|
| if ($LASTEXITCODE -eq 0 -and $scriptNames) {
|
| $expected = @($scriptNames.Trim().Split(',') | Where-Object { $_ })
|
| $missing = @()
|
| foreach ($name in $expected) {
|
| $exe = Join-Path $scriptsDir "$name.exe"
|
| if (-not (Test-Path $exe)) { $missing += "$name.exe" }
|
| }
|
| if ($missing.Count -gt 0) {
|
| Write-Warn "Console entry point(s) missing: $($missing -join ', ')"
|
| Write-Info "Reinstalling entry points..."
|
| $env:UV_PROJECT_ENVIRONMENT = "$InstallDir\venv"
|
| Invoke-NativeWithRelaxedErrorAction { & $UvCmd pip install --reinstall -e . }
|
| $stillMissing = @()
|
| foreach ($name in $expected) {
|
| $exe = Join-Path $scriptsDir "$name.exe"
|
| if (-not (Test-Path $exe)) { $stillMissing += "$name.exe" }
|
| }
|
| if ($stillMissing.Count -gt 0) {
|
| Write-Warn "Entry points still missing after repair: $($stillMissing -join ', ')"
|
| Write-Info "Workaround: `"$pythonExe`" -m hermes_cli.main <command>"
|
| } else {
|
| Write-Success "Console entry points restored"
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| $pythonExe = if (-not $NoVenv) { "$InstallDir\venv\Scripts\python.exe" } else { (& $UvCmd python find $PythonVersion) }
|
| if (Test-Path $pythonExe) {
|
| $webOk = $false
|
| $webServerSyntaxOk = $false
|
|
|
|
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
| & $pythonExe -c "import fastapi, uvicorn" 2>&1 | Out-Null
|
| if ($LASTEXITCODE -eq 0) { $webOk = $true }
|
| } catch { }
|
| try {
|
| & $pythonExe -m py_compile "$InstallDir\hermes_cli\web_server.py" 2>&1 | Out-Null
|
| if ($LASTEXITCODE -eq 0) { $webServerSyntaxOk = $true }
|
| } catch { }
|
| $ErrorActionPreference = $prevEAP
|
| if (-not $webOk) {
|
| Write-Warn "fastapi/uvicorn not importable -- `hermes dashboard` will not work."
|
| Write-Info "Attempting targeted install of [web] extra as last resort..."
|
| & $UvCmd pip install -e ".[web]"
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "[web] extra installed; `hermes dashboard` should now work."
|
| } else {
|
| Write-Warn "Could not install [web] extra. Run manually: uv pip install --python `"$pythonExe`" `"fastapi>=0.104,<1`" `"uvicorn[standard]>=0.24,<1`""
|
| }
|
| }
|
| if (-not $webServerSyntaxOk) {
|
| throw "dashboard backend source failed syntax check: hermes_cli/web_server.py"
|
| }
|
| }
|
|
|
| Pop-Location
|
|
|
| Write-Success "All dependencies installed"
|
| }
|
|
|
| function Install-HermesCommandLaunchers {
|
| param(
|
| [Parameter(Mandatory=$true)] [string]$Root,
|
| [Parameter(Mandatory=$true)] [string]$Destination
|
| )
|
|
|
|
|
|
|
|
|
|
|
|
|
| $scriptsDir = Join-Path $Root "venv\Scripts"
|
| $requiredSource = Join-Path $scriptsDir "hermes.exe"
|
| if (-not (Test-Path -LiteralPath $requiredSource -PathType Leaf)) {
|
| throw "Cannot set up the hermes command: required launcher not found: $requiredSource"
|
| }
|
|
|
| New-Item -ItemType Directory -Force -Path $Destination | Out-Null
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $pyvenvCfg = Join-Path $Root "venv\pyvenv.cfg"
|
| $venvRelocatable = $false
|
| if (Test-Path -LiteralPath $pyvenvCfg) {
|
| $venvRelocatable = [bool](Select-String -Path $pyvenvCfg -Pattern '^\s*relocatable\s*=\s*true\s*$' -Quiet)
|
| }
|
| foreach ($launcher in @("hermes", "hermes-acp")) {
|
| $src = Join-Path $scriptsDir "$launcher.exe"
|
| if (-not (Test-Path -LiteralPath $src -PathType Leaf)) { continue }
|
| if ($venvRelocatable) {
|
| Remove-Item (Join-Path $Destination "$launcher.exe") -Force -ErrorAction SilentlyContinue
|
| Set-Content -Path (Join-Path $Destination "$launcher.cmd") -Value "@echo off`r`n`"$src`" %*" -Encoding Ascii
|
| } else {
|
| Remove-Item (Join-Path $Destination "$launcher.cmd") -Force -ErrorAction SilentlyContinue
|
| Copy-Item -Force -LiteralPath $src -Destination (Join-Path $Destination "$launcher.exe")
|
| }
|
| }
|
|
|
|
|
| $requiredExe = Join-Path $Destination "hermes.exe"
|
| $requiredCmd = Join-Path $Destination "hermes.cmd"
|
| if (-not ((Test-Path -LiteralPath $requiredExe -PathType Leaf) -or
|
| (Test-Path -LiteralPath $requiredCmd -PathType Leaf))) {
|
| throw "Cannot set up the hermes command: launcher was not installed: $requiredExe"
|
| }
|
| return $Destination
|
| }
|
|
|
| function Set-PathVariable {
|
| Write-Info "Setting up hermes command..."
|
|
|
| if ($NoVenv) {
|
| $hermesBin = "$InstallDir"
|
| } else {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $hermesBin = "$HermesHome\bin"
|
| Install-HermesCommandLaunchers -Root $InstallDir -Destination $hermesBin | Out-Null
|
| }
|
|
|
| $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not $NoVenv) {
|
| $legacyEntries = @("$InstallDir\venv\Scripts", "$InstallDir\bin")
|
| $items = @(($currentPath -split ';') | Where-Object { $_ })
|
| $cleaned = @($items | Where-Object { $legacyEntries -notcontains $_ })
|
| if ($cleaned.Count -ne $items.Count) {
|
| $currentPath = $cleaned -join ";"
|
| [Environment]::SetEnvironmentVariable("Path", $currentPath, "User")
|
| Write-Info "Removed legacy launcher entries from user PATH (kept hermes via $hermesBin)"
|
| }
|
| }
|
|
|
| if ($currentPath -notlike "*$hermesBin*") {
|
| [Environment]::SetEnvironmentVariable(
|
| "Path",
|
| "$hermesBin;$currentPath",
|
| "User"
|
| )
|
| Write-Success "Added to user PATH: $hermesBin"
|
| } else {
|
| Write-Info "PATH already configured"
|
| }
|
|
|
|
|
|
|
|
|
| $currentHermesHome = [Environment]::GetEnvironmentVariable("HERMES_HOME", "User")
|
| if (-not $currentHermesHome -or $currentHermesHome -ne $HermesHome) {
|
| [Environment]::SetEnvironmentVariable("HERMES_HOME", $HermesHome, "User")
|
| Write-Success "Set HERMES_HOME=$HermesHome"
|
| }
|
| $env:HERMES_HOME = $HermesHome
|
|
|
|
|
| $env:Path = "$hermesBin;$env:Path"
|
|
|
| Write-Success "hermes command ready"
|
| }
|
|
|
| function Write-BootstrapMarker {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not (Test-Path $InstallDir)) {
|
| Write-Warn "Skipping bootstrap marker: $InstallDir doesn't exist"
|
| return
|
| }
|
|
|
|
|
|
|
|
|
|
|
| $pinnedCommit = $Commit
|
| if (-not $pinnedCommit) {
|
|
|
|
|
| $gitCmd = Get-Command git -ErrorAction SilentlyContinue
|
| $gitExe = if ($gitCmd) { $gitCmd.Source } else { $null }
|
| if ($gitExe) {
|
| Push-Location $InstallDir
|
| try {
|
| $resolved = & $gitExe rev-parse HEAD 2>$null
|
| if ($LASTEXITCODE -eq 0 -and $resolved) {
|
| $pinnedCommit = $resolved.Trim()
|
| }
|
| } catch {
|
|
|
|
|
| } finally {
|
| Pop-Location
|
| }
|
| }
|
| }
|
|
|
| $pinnedBranch = $Branch
|
| if (-not $pinnedBranch) {
|
| $pinnedBranch = "main"
|
| }
|
|
|
| $markerPath = Join-Path $InstallDir ".hermes-bootstrap-complete"
|
| $marker = [ordered]@{
|
| schemaVersion = 1
|
| pinnedCommit = $pinnedCommit
|
| pinnedBranch = $pinnedBranch
|
| completedAt = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
|
|
|
|
|
|
|
|
|
| }
|
| $json = $marker | ConvertTo-Json -Compress:$false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $utf8NoBom = New-Object System.Text.UTF8Encoding $false
|
| [System.IO.File]::WriteAllText($markerPath, $json, $utf8NoBom)
|
|
|
| Write-Success "Bootstrap marker written: $markerPath"
|
| }
|
|
|
| function Copy-ConfigTemplates {
|
| Write-Info "Setting up configuration files..."
|
|
|
|
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\cron" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\sessions" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\logs" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\pairing" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\hooks" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\image_cache" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\audio_cache" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\memories" | Out-Null
|
| New-Item -ItemType Directory -Force -Path "$HermesHome\skills" | Out-Null
|
|
|
|
|
|
|
| $envPath = "$HermesHome\.env"
|
| if (-not (Test-Path $envPath)) {
|
| $examplePath = "$InstallDir\.env.example"
|
| if (Test-Path $examplePath) {
|
| Copy-Item $examplePath $envPath
|
| Write-Success "Created $envPath from template"
|
| } else {
|
| New-Item -ItemType File -Force -Path $envPath | Out-Null
|
| Write-Success "Created $envPath"
|
| }
|
| } else {
|
| Write-Info "$envPath already exists, keeping it"
|
| }
|
|
|
|
|
| $configPath = "$HermesHome\config.yaml"
|
| if (-not (Test-Path $configPath)) {
|
| $examplePath = "$InstallDir\cli-config.yaml.example"
|
| if (Test-Path $examplePath) {
|
| Copy-Item $examplePath $configPath
|
| Write-Success "Created $configPath from template"
|
| }
|
| } else {
|
| Write-Info "$configPath already exists, keeping it"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $soulPath = "$HermesHome\SOUL.md"
|
| if (-not (Test-Path $soulPath)) {
|
|
|
|
|
|
|
| $soulContent = @"
|
| You are Hermes Agent, built by Nous Research. Be direct: match the length of your reply to the weight of the ask -- a one-line question gets a one-line answer, and finished work gets a short report of what changed, what's verified, and what's left, never a replay of the process. No filler ("Great question," "I'd be happy to"), no restating the request back, no re-summarizing what you already said, no narrating tool calls the user can see. Plain claims over adjectives; when unsure, say so plainly. Agree because it's right, not because the user said it. Depth is earned -- give it when the user asks for detail, teaches, or the stakes demand it, not by default.
|
| "@
|
| $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
| [System.IO.File]::WriteAllText($soulPath, $soulContent, $utf8NoBom)
|
| Write-Success "Created $soulPath (edit to customize personality)"
|
| }
|
|
|
| Write-Success "Configuration directory ready: $HermesHome"
|
|
|
|
|
| Write-Info "Syncing bundled skills to $HermesHome\skills ..."
|
| $pythonExe = "$InstallDir\venv\Scripts\python.exe"
|
| if (Test-Path $pythonExe) {
|
| try {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $prevPythonioencoding = $env:PYTHONIOENCODING
|
| $prevPythonutf8 = $env:PYTHONUTF8
|
| $env:PYTHONIOENCODING = "utf-8"
|
| $env:PYTHONUTF8 = "1"
|
| try {
|
| & $pythonExe "$InstallDir\tools\skills_sync.py" 2>$null
|
| } finally {
|
| $env:PYTHONIOENCODING = $prevPythonioencoding
|
| $env:PYTHONUTF8 = $prevPythonutf8
|
| }
|
| Write-Success "Skills synced to $HermesHome\skills"
|
| } catch {
|
|
|
| $bundledSkills = "$InstallDir\skills"
|
| $userSkills = "$HermesHome\skills"
|
| if ((Test-Path $bundledSkills) -and -not (Get-ChildItem $userSkills -Exclude '.bundled_manifest' -ErrorAction SilentlyContinue)) {
|
| Copy-Item -Path "$bundledSkills\*" -Destination $userSkills -Recurse -Force -ErrorAction SilentlyContinue
|
| Write-Success "Skills copied to $HermesHome\skills"
|
| }
|
| }
|
| }
|
| }
|
|
|
| function Install-NodeDeps {
|
| if (-not $HasNode) {
|
|
|
|
|
|
|
|
|
|
|
| if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
|
| Write-Info "Skipping Node.js dependencies (Node not installed)"
|
| return
|
| }
|
| }
|
|
|
|
|
|
|
|
|
| Ensure-NodeExeOnPath | Out-Null
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $npmCmd = Get-Command npm -ErrorAction SilentlyContinue
|
| if (-not $npmCmd) {
|
| Write-Warn "npm not found on PATH -- skipping Node.js dependencies."
|
| Write-Info "Open a new PowerShell window and re-run 'hermes setup tools' later."
|
| return
|
| }
|
| $npmExe = $npmCmd.Source
|
| if ($npmExe -like "*.ps1") {
|
| $npmCmdSibling = Join-Path (Split-Path $npmExe -Parent) "npm.cmd"
|
| if (Test-Path $npmCmdSibling) {
|
| Write-Info "Using npm.cmd (PowerShell execution policy blocks npm.ps1)"
|
| $npmExe = $npmCmdSibling
|
| } else {
|
| Write-Warn "Only npm.ps1 available -- install may fail if script execution is disabled."
|
| Write-Info " If it fails, either enable PS script execution or install Node via winget."
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $nodeDepsTimeoutSec = 600
|
| if ($env:NODE_DEPS_TIMEOUT -match '^\d+$') {
|
| $nodeDepsTimeoutSec = [int]$env:NODE_DEPS_TIMEOUT
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function _Invoke-NativeWithTimeout(
|
| [string]$exePath, [string]$argLine, [string]$workDir,
|
| [string]$logPath, [int]$timeoutSec
|
| ) {
|
| $cmdLine = "/d /s /c "" ""$exePath"" $argLine > ""$logPath"" 2>&1 """
|
| $proc = Start-Process -FilePath $env:ComSpec -ArgumentList $cmdLine `
|
| -WorkingDirectory $workDir -NoNewWindow -PassThru
|
| $deadline = [DateTime]::UtcNow.AddSeconds($timeoutSec)
|
| $shown = 0
|
| function _Drain-NewLines([string]$path, [ref]$count) {
|
| $lines = @(Get-Content $path -ErrorAction SilentlyContinue)
|
| if ($lines.Count -gt $count.Value) {
|
| $lines[$count.Value..($lines.Count - 1)] | ForEach-Object {
|
| Write-Host " $_" -ForegroundColor DarkGray
|
| }
|
| $count.Value = $lines.Count
|
| }
|
| }
|
| while (-not $proc.HasExited) {
|
| if ([DateTime]::UtcNow -gt $deadline) {
|
| & taskkill /T /F /PID $proc.Id 2>&1 | Out-Null
|
| return 124
|
| }
|
| Start-Sleep -Milliseconds 750
|
| _Drain-NewLines $logPath ([ref]$shown)
|
| }
|
| _Drain-NewLines $logPath ([ref]$shown)
|
| return $proc.ExitCode
|
| }
|
|
|
|
|
|
|
| function _Run-NpmInstall([string]$label, [string]$installDir, [string]$logPath, [string]$npmPath) {
|
| Push-Location $installDir
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $ErrorActionPreference = "Continue"
|
| $code = _Invoke-NativeWithTimeout $npmPath "install --silent" `
|
| $installDir $logPath $nodeDepsTimeoutSec
|
| $ErrorActionPreference = $prevEAP
|
| if ($code -eq 0) {
|
| Write-Success "$label dependencies installed"
|
| Remove-Item -Force $logPath -ErrorAction SilentlyContinue
|
| return $true
|
| }
|
| if ($code -eq 124) {
|
| Write-Warn "$label npm install timed out after $([math]::Round($nodeDepsTimeoutSec / 60)) minutes -- a stalled download, wedged extraction, or file lock is the usual cause."
|
| Write-Info " Re-run the installer to retry (completed stages are skipped)."
|
| Write-Info " Slow connection? Raise the ceiling: set NODE_DEPS_TIMEOUT to seconds (default 600)."
|
| } else {
|
| Write-Warn "$label npm install failed -- exit code $code"
|
| }
|
| if (Test-Path $logPath) {
|
| $errText = (Get-Content $logPath -Raw -ErrorAction SilentlyContinue)
|
| if ($errText) {
|
| $snippet = if ($errText.Length -gt 1200) { $errText.Substring(0, 1200) + "..." } else { $errText }
|
| Write-Info " npm output:"
|
| foreach ($line in $snippet -split "`n") {
|
| Write-Host " $line" -ForegroundColor DarkGray
|
| }
|
| Write-Info " Full log: $logPath"
|
| Show-NpmCertHint $errText | Out-Null
|
| Write-NpmDebugLogTail -NpmOutput $errText
|
| }
|
| }
|
| Write-Info "Run manually later: cd `"$installDir`"; npm install"
|
| return $false
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Write-Warn "$label npm install could not be launched: $_"
|
| return $false
|
| } finally {
|
| Pop-Location
|
| }
|
| }
|
|
|
|
|
| if (Test-Path "$InstallDir\package.json") {
|
| Write-Info "Installing Node.js dependencies (browser tools)..."
|
| $browserLog = "$env:TEMP\hermes-npm-browser-$(Get-Random).log"
|
| $browserNpmOk = _Run-NpmInstall "Browser tools" $InstallDir $browserLog $npmExe
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($browserNpmOk) {
|
| Write-Info "Installing browser engine (Playwright Chromium)..."
|
|
|
|
|
| $npmDir = Split-Path $npmExe -Parent
|
| $npxExe = $null
|
| foreach ($cand in @("npx.cmd", "npx.exe", "npx")) {
|
| $try = Join-Path $npmDir $cand
|
| if (Test-Path $try) { $npxExe = $try; break }
|
| }
|
| if (-not $npxExe) {
|
| $npxCmd = Get-Command npx -ErrorAction SilentlyContinue
|
| if ($npxCmd) { $npxExe = $npxCmd.Source }
|
| }
|
| if (-not $npxExe) {
|
| Write-Warn "npx not found -- cannot install Playwright Chromium."
|
| Write-Info "Run manually later: cd `"$InstallDir`"; npx playwright install chromium"
|
| } else {
|
| $pwLog = "$env:TEMP\hermes-playwright-install-$(Get-Random).log"
|
| Push-Location $InstallDir
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "(this can take several minutes -- streaming progress below)"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $ErrorActionPreference = "Continue"
|
| $pwCode = _Invoke-NativeWithTimeout $npxExe "--yes playwright install chromium" `
|
| $InstallDir $pwLog $nodeDepsTimeoutSec
|
| $ErrorActionPreference = $prevEAP
|
| if ($pwCode -eq 0) {
|
| Write-Success "Playwright Chromium installed (browser tools ready)"
|
| Remove-Item -Force $pwLog -ErrorAction SilentlyContinue
|
| } elseif ($pwCode -eq 124) {
|
| Write-Warn "Playwright Chromium install timed out after $([math]::Round($nodeDepsTimeoutSec / 60)) minutes."
|
| Write-Warn "This usually means a stalled download or a wedged archive extraction (a locked previous browser version can also cause it)."
|
| Write-Warn "Browser tools will not work until Chromium is installed."
|
| if (Test-Path $pwLog) { Write-Info " Partial log: $pwLog" }
|
| Write-Info "Run manually later: cd `"$InstallDir`"; npx playwright install chromium"
|
| } else {
|
| Write-Warn "Playwright Chromium install failed -- exit code $pwCode"
|
| Write-Warn "Browser tools will not work until Chromium is installed."
|
| if (Test-Path $pwLog) {
|
| $pwErr = Get-Content $pwLog -Raw -ErrorAction SilentlyContinue
|
| if ($pwErr) {
|
| $snippet = if ($pwErr.Length -gt 1200) { $pwErr.Substring(0, 1200) + "..." } else { $pwErr }
|
| Write-Info " playwright output:"
|
| foreach ($line in $snippet -split "`n") {
|
| Write-Host " $line" -ForegroundColor DarkGray
|
| }
|
| Write-Info " Full log: $pwLog"
|
| }
|
| }
|
| Write-Info "Run manually later: cd `"$InstallDir`"; npx playwright install chromium"
|
| }
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Write-Warn "Playwright Chromium install could not be launched: $_"
|
| Write-Info "Run manually later: cd `"$InstallDir`"; npx playwright install chromium"
|
| } finally {
|
| Pop-Location
|
| }
|
| }
|
| }
|
| }
|
|
|
|
|
| $tuiDir = "$InstallDir\ui-tui"
|
| if (Test-Path "$tuiDir\package.json") {
|
| Write-Info "Installing TUI dependencies..."
|
| $tuiLog = "$env:TEMP\hermes-npm-tui-$(Get-Random).log"
|
| [void](_Run-NpmInstall "TUI" $tuiDir $tuiLog $npmExe)
|
| }
|
|
|
| Install-BrowserUseCli
|
| Install-CuaDriver
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Install-BrowserUseCli {
|
| if (-not $script:UvCmd) { Resolve-UvCmd }
|
| if (-not $script:UvCmd) {
|
| Write-Info "Skipping Browser Use CLI install (uv unavailable)"
|
| return
|
| }
|
| $managedBin = Join-Path $HermesHome "bin"
|
| $managedBu = Join-Path $managedBin "browser-use.exe"
|
|
|
|
|
|
|
| if (Test-Path $managedBu) {
|
| Write-Success "Browser Use CLI already installed"
|
| return
|
| }
|
|
|
| Write-Info "Installing Browser Use CLI (default browser backend)..."
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
|
|
|
|
| $env:UV_TOOL_BIN_DIR = $managedBin
|
| $env:UV_NO_CONFIG = "1"
|
| & $script:UvCmd tool install browser-use 2>&1 | Out-Null
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "Browser Use CLI installed"
|
| } else {
|
| Write-Warn "Browser Use CLI install failed (exit $LASTEXITCODE) -- browser automation falls back to built-in tools."
|
| Write-Info "Install later with: uv tool install browser-use (or via 'hermes tools')"
|
| }
|
| } catch {
|
| Write-Warn "Browser Use CLI install failed: $_"
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| Remove-Item Env:\UV_TOOL_BIN_DIR -ErrorAction SilentlyContinue
|
| Remove-Item Env:\UV_NO_CONFIG -ErrorAction SilentlyContinue
|
| }
|
| }
|
|
|
| function Test-CuaDriverRuntimeContract {
|
| param([Parameter(Mandatory = $true)][string]$DriverPath)
|
|
|
| try {
|
| $versionOutput = (& $DriverPath --version 2>$null | Out-String).Trim()
|
| if ($LASTEXITCODE -ne 0) {
|
| return $false
|
| }
|
| $versionMatch = [regex]::Match($versionOutput, '(\d+\.\d+\.\d+)')
|
| if (-not $versionMatch.Success) {
|
| return $false
|
| }
|
| if ([version]($versionMatch.Groups[1].Value) -lt [version]'0.20.0') {
|
| return $false
|
| }
|
|
|
| $manifestOutput = (& $DriverPath manifest 2>$null | Out-String).Trim()
|
| if ($LASTEXITCODE -ne 0 -or -not $manifestOutput) {
|
| return $false
|
| }
|
| $manifest = $manifestOutput | ConvertFrom-Json
|
| if (-not $manifest.mcp_invocation.args) {
|
| return $false
|
| }
|
|
|
| $required = @{
|
| mcp = @('--socket', '--grant')
|
| serve = @(
|
| '--socket', '--permission-mode', '--capability-manifest',
|
| '--approve-capability-manifest', '--embedded'
|
| )
|
| stop = @('--socket')
|
| }
|
| foreach ($commandName in $required.Keys) {
|
| $command = $manifest.subcommands | Where-Object { $_.name -eq $commandName }
|
| if (-not $command) {
|
| return $false
|
| }
|
| $argNames = @($command.args | ForEach-Object { $_.name })
|
| foreach ($requiredArg in $required[$commandName]) {
|
| if ($requiredArg -notin $argNames) {
|
| return $false
|
| }
|
| }
|
| }
|
| return $true
|
| } catch {
|
| return $false
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Install-CuaDriver {
|
| if ($SkipComputerUse) {
|
| Write-Info "Skipping Computer Use (cua-driver) install (-SkipComputerUse)"
|
| return
|
| }
|
| $existingCuaDriver = Get-Command cua-driver -ErrorAction SilentlyContinue
|
| if ($existingCuaDriver) {
|
| if (Test-CuaDriverRuntimeContract -DriverPath $existingCuaDriver.Source) {
|
| Write-Success "Computer Use driver (cua-driver) already installed and compatible"
|
| return
|
| }
|
| Write-Warn "Existing cua-driver is old or incomplete; repairing it"
|
| }
|
|
|
| Write-Info "Installing Computer Use driver (cua-driver)..."
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "Continue"
|
| try {
|
|
|
|
|
|
|
|
|
| $job = Start-Job -ScriptBlock {
|
| Invoke-RestMethod -UseBasicParsing "https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.ps1" | Invoke-Expression
|
| }
|
| if (Wait-Job $job -Timeout 660) {
|
| Receive-Job $job -ErrorAction SilentlyContinue | Out-Null
|
| Remove-Job $job -Force -ErrorAction SilentlyContinue
|
| $installedCuaDriver = Get-Command cua-driver -ErrorAction SilentlyContinue
|
| if ($installedCuaDriver -and (Test-CuaDriverRuntimeContract -DriverPath $installedCuaDriver.Source)) {
|
| Write-Success "Computer Use driver installed (enable via 'hermes tools' -> Computer Use)"
|
| } else {
|
| Write-Warn "Computer Use driver install did not produce a compatible runtime -- repair it before enabling the tool."
|
| Write-Info "Install later with: hermes computer-use install"
|
| }
|
| } else {
|
| Stop-Job $job -ErrorAction SilentlyContinue
|
| Remove-Job $job -Force -ErrorAction SilentlyContinue
|
| Write-Warn "Computer Use driver install timed out -- it will install on demand when you enable the tool."
|
| Write-Info "Install later with: hermes computer-use install"
|
| }
|
| } catch {
|
| Write-Warn "Computer Use driver install failed: $_"
|
| Write-Info "Install later with: hermes computer-use install"
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Clear-ElectronBuildCache {
|
| param([string]$DesktopDir)
|
| $removed = @()
|
|
|
|
|
|
|
| $cacheDirs = @()
|
| if ($env:electron_config_cache) { $cacheDirs += $env:electron_config_cache }
|
| if ($env:ELECTRON_CACHE) { $cacheDirs += $env:ELECTRON_CACHE }
|
| if ($env:LOCALAPPDATA) { $cacheDirs += (Join-Path $env:LOCALAPPDATA 'electron\Cache') }
|
| $cacheDirs += (Join-Path $HOME 'AppData\Local\electron\Cache')
|
|
|
| foreach ($dir in $cacheDirs) {
|
| if (-not (Test-Path -LiteralPath $dir)) { continue }
|
|
|
|
|
| $removed += @(Get-ChildItem -LiteralPath $dir -Recurse -Filter 'electron-*.zip' -File -ErrorAction SilentlyContinue | ForEach-Object {
|
| try { Remove-Item -LiteralPath $_.FullName -Force -ErrorAction Stop; $_.FullName } catch { }
|
| })
|
| }
|
|
|
|
|
|
|
| $releaseDir = Join-Path $DesktopDir 'release'
|
| if (Test-Path -LiteralPath $releaseDir) {
|
| $removed += @(Get-ChildItem -LiteralPath $releaseDir -Directory -Filter '*-unpacked' -ErrorAction SilentlyContinue | ForEach-Object {
|
| try { Remove-Item -LiteralPath $_.FullName -Recurse -Force -ErrorAction Stop; $_.FullName } catch { }
|
| })
|
| }
|
|
|
| return $removed
|
| }
|
|
|
|
|
| $script:DesktopElectronFallbackMirror = "https://npmmirror.com/mirrors/electron/"
|
|
|
|
|
| function Get-ElectronDir {
|
| param([string]$InstallDir)
|
| $desktopLocal = Join-Path $InstallDir 'apps\desktop\node_modules\electron'
|
| if (Test-Path -LiteralPath $desktopLocal) { return $desktopLocal }
|
| return (Join-Path $InstallDir 'node_modules\electron')
|
| }
|
|
|
|
|
| function Test-ElectronDist {
|
| param([string]$InstallDir)
|
| $electronDir = Get-ElectronDir -InstallDir $InstallDir
|
| $distExe = Join-Path $electronDir 'dist\electron.exe'
|
| return (Test-Path -LiteralPath $distExe)
|
| }
|
|
|
|
|
| function Restore-ElectronDist {
|
| param([string]$InstallDir, [string]$Mirror)
|
| if (Test-ElectronDist -InstallDir $InstallDir) { return $true }
|
|
|
| $electronDir = Get-ElectronDir -InstallDir $InstallDir
|
| $distExe = Join-Path $electronDir 'dist\electron.exe'
|
| $installer = Join-Path $electronDir 'install.js'
|
| if (-not (Test-Path -LiteralPath $installer)) { return $false }
|
| $node = Get-Command node -ErrorAction SilentlyContinue
|
| if (-not $node) { return $false }
|
|
|
| $distDir = Join-Path $electronDir 'dist'
|
| if (Test-Path -LiteralPath $distDir) {
|
| Remove-Item -LiteralPath $distDir -Recurse -Force -ErrorAction SilentlyContinue
|
| }
|
| Remove-Item -LiteralPath (Join-Path $electronDir 'path.txt') -Force -ErrorAction SilentlyContinue
|
|
|
| $prevMirror = $env:ELECTRON_MIRROR
|
| if ($Mirror) { $env:ELECTRON_MIRROR = $Mirror }
|
| try {
|
|
|
|
|
|
|
|
|
| & $node.Source $installer 2>&1 | ForEach-Object { "$_" } | Out-Host
|
| } catch {
|
| } finally {
|
| $env:ELECTRON_MIRROR = $prevMirror
|
| }
|
| return (Test-Path -LiteralPath $distExe)
|
| }
|
|
|
| function Test-ElectronPkgStagedMissingDist {
|
| param([string]$InstallDir)
|
| $electronDir = Get-ElectronDir -InstallDir $InstallDir
|
| return (
|
| (Test-Path -LiteralPath (Join-Path $electronDir 'package.json')) -and
|
| (Test-Path -LiteralPath (Join-Path $electronDir 'install.js')) -and
|
| (-not (Test-ElectronDist -InstallDir $InstallDir))
|
| )
|
| }
|
|
|
| function Try-RestoreElectronDist {
|
| param([string]$InstallDir)
|
| if (Restore-ElectronDist -InstallDir $InstallDir) { return $true }
|
| if ($env:ELECTRON_MIRROR) { return $false }
|
| return Restore-ElectronDist -InstallDir $InstallDir -Mirror $script:DesktopElectronFallbackMirror
|
| }
|
|
|
| function Install-DesktopVoiceDeps {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not $script:UvCmd) { Resolve-UvCmd }
|
| if (-not $script:UvCmd) {
|
| Write-Warn "uv unavailable -- voice/wake deps will lazy-install at first use instead"
|
| return
|
| }
|
| $env:VIRTUAL_ENV = "$InstallDir\venv"
|
| Write-Info "Installing voice + wake-word dependencies (onnxruntime, faster-whisper -- 1-3min)..."
|
| Push-Location $InstallDir
|
| try {
|
| Invoke-NativeWithRelaxedErrorAction { & $UvCmd pip install -e ".[wake,voice]" }
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "Voice + wake-word dependencies installed"
|
| } else {
|
| Write-Warn "Voice/wake dependency install failed (exit $LASTEXITCODE) -- they will lazy-install at first use"
|
| }
|
| } finally {
|
| Pop-Location
|
| }
|
| }
|
|
|
| function Install-Desktop {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Test-Node | Out-Null
|
| if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
|
| Write-Warn "Skipping desktop build (Node.js / npm not on PATH)"
|
| $script:_StageSkippedReason = "Node.js not available"
|
| return
|
| }
|
|
|
| $desktopDir = "$InstallDir\apps\desktop"
|
| if (-not (Test-Path "$desktopDir\package.json")) {
|
| Write-Warn "Skipping desktop build (apps/desktop not present in checkout)"
|
| $script:_StageSkippedReason = "apps/desktop not present"
|
| return
|
| }
|
|
|
| $npmCmd = Get-Command npm -ErrorAction SilentlyContinue
|
| if (-not $npmCmd) {
|
| Write-Warn "Skipping desktop build (npm not on PATH)"
|
| $script:_StageSkippedReason = "npm not found"
|
| return
|
| }
|
| $npmExe = $npmCmd.Source
|
| if ($npmExe -like "*.ps1") {
|
| $sibling = Join-Path (Split-Path $npmExe -Parent) "npm.cmd"
|
| if (Test-Path $sibling) { $npmExe = $sibling }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "Installing desktop workspace dependencies (this includes Electron ~150MB, takes 1-3min)..."
|
| Push-Location $InstallDir
|
| $prevEAP = $ErrorActionPreference
|
| try {
|
| $ErrorActionPreference = "Continue"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| & $npmExe ci 2>&1 | ForEach-Object { "$_" } | Tee-Object -Variable npmOut
|
| $code = $LASTEXITCODE
|
| if ($code -ne 0) {
|
| Write-Info " npm ci failed (exit $code) -- retrying with npm install..."
|
| & $npmExe install 2>&1 | ForEach-Object { "$_" } | Tee-Object -Variable npmOut
|
| $code = $LASTEXITCODE
|
| }
|
| $ErrorActionPreference = $prevEAP
|
| if ($code -ne 0) {
|
| if (Test-ElectronPkgStagedMissingDist -InstallDir $InstallDir) {
|
| Write-Warn "Desktop dependency install failed with a missing Electron dist; attempting self-heal..."
|
| Try-RestoreElectronDist -InstallDir $InstallDir | Out-Null
|
| } else {
|
| Show-NpmCertHint ($npmOut -join "`n") | Out-Null
|
|
|
|
|
|
|
| Write-NpmDebugLogTail -NpmOutput ($npmOut -join "`n")
|
| throw "desktop workspace npm install failed (exit $code) -- see lines above for cause"
|
| }
|
| } else {
|
| Write-Success "Desktop workspace dependencies installed"
|
| }
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Pop-Location
|
| throw
|
| }
|
| Pop-Location
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Write-Info "Building desktop app (this takes 1-3 minutes)..."
|
| $buildLog = "$env:TEMP\hermes-desktop-build-$(Get-Random).log"
|
|
|
|
|
|
|
|
|
|
|
| if (-not $env:GITHUB_SHA) {
|
| if ($Commit) {
|
| $env:GITHUB_SHA = $Commit
|
| } else {
|
| Push-Location $InstallDir
|
| try {
|
| $global:LASTEXITCODE = 0
|
| $resolvedSha = & git -c windows.appendAtomically=false rev-parse HEAD 2>$null
|
| if ($LASTEXITCODE -ne 0 -or -not $resolvedSha) {
|
|
|
| $global:LASTEXITCODE = 0
|
| $resolvedSha = & git -c windows.appendAtomically=false rev-parse FETCH_HEAD 2>$null
|
| }
|
| if ($LASTEXITCODE -eq 0 -and $resolvedSha) {
|
| $env:GITHUB_SHA = ("$resolvedSha").Trim()
|
| }
|
| } catch { } finally {
|
| Pop-Location
|
| }
|
| }
|
| }
|
| if (-not $env:GITHUB_REF_NAME) {
|
| $env:GITHUB_REF_NAME = if ($Branch) { $Branch } else { "main" }
|
| }
|
| if ($env:GITHUB_SHA) {
|
| $shaPreview = if ($env:GITHUB_SHA.Length -ge 12) { $env:GITHUB_SHA.Substring(0, 12) } else { $env:GITHUB_SHA }
|
| Write-Info "Desktop build stamp: $shaPreview ($($env:GITHUB_REF_NAME))"
|
| } else {
|
| Write-Warn "Could not resolve a git commit for the desktop stamp -- write-build-stamp will use its non-git fallback"
|
| }
|
| Push-Location $desktopDir
|
| $prevEAP = $ErrorActionPreference
|
| $prevCSCAuto = $env:CSC_IDENTITY_AUTO_DISCOVERY
|
| $prevWinCscLink = $env:WIN_CSC_LINK
|
| $prevWinCscKeyPassword = $env:WIN_CSC_KEY_PASSWORD
|
| try {
|
| $ErrorActionPreference = "Continue"
|
| $env:CSC_IDENTITY_AUTO_DISCOVERY = "false"
|
| $env:WIN_CSC_LINK = ""
|
| $env:WIN_CSC_KEY_PASSWORD = ""
|
| & $npmExe run pack 2>&1 | ForEach-Object { "$_" } | Tee-Object -FilePath $buildLog
|
| $code = $LASTEXITCODE
|
| if ($code -ne 0) {
|
| $purged = @()
|
| $restored = $false
|
| if (-not (Test-ElectronDist -InstallDir $InstallDir)) {
|
| $purged = @(Clear-ElectronBuildCache -DesktopDir $desktopDir)
|
| $restored = Restore-ElectronDist -InstallDir $InstallDir
|
| }
|
| if ($restored) {
|
| Write-Warn "Desktop build failed - refreshed the Electron download, retrying once:"
|
| foreach ($p in $purged) { Write-Info " - $p" }
|
| & $npmExe run pack 2>&1 | ForEach-Object { "$_" } | Tee-Object -FilePath $buildLog
|
| $code = $LASTEXITCODE
|
| }
|
| }
|
| if ($code -ne 0 -and -not $env:ELECTRON_MIRROR) {
|
| $mirror = $script:DesktopElectronFallbackMirror
|
| Write-Warn "Desktop build still failing - the Electron download from GitHub looks blocked."
|
| Write-Warn "Re-downloading Electron via a public mirror ($mirror), then rebuilding:"
|
| Write-Info " (set ELECTRON_MIRROR yourself to use a different/trusted mirror)"
|
| if (-not (Test-ElectronDist -InstallDir $InstallDir)) {
|
| Restore-ElectronDist -InstallDir $InstallDir -Mirror $mirror | Out-Null
|
| }
|
| $prevMirror = $env:ELECTRON_MIRROR
|
| $env:ELECTRON_MIRROR = $mirror
|
| try {
|
| & $npmExe run pack 2>&1 | ForEach-Object { "$_" } | Tee-Object -FilePath $buildLog
|
| $code = $LASTEXITCODE
|
| } finally {
|
| $env:ELECTRON_MIRROR = $prevMirror
|
| }
|
| }
|
| $ErrorActionPreference = $prevEAP
|
| if ($code -ne 0) {
|
| $errText = Get-Content $buildLog -Raw -ErrorAction SilentlyContinue
|
| if ($errText) {
|
| $snippet = if ($errText.Length -gt 1800) { $errText.Substring(0, 1800) + "..." } else { $errText }
|
| Write-Info " desktop build output:"
|
| foreach ($line in $snippet -split "`n") { Write-Host " $line" -ForegroundColor DarkGray }
|
| Write-Info " Full log: $buildLog"
|
| }
|
|
|
|
|
|
|
| Write-NpmDebugLogTail -NpmOutput $errText
|
| throw "apps/desktop build failed (exit $code)"
|
| }
|
| Write-Success "Desktop app built"
|
| Remove-Item -LiteralPath $buildLog -Force -ErrorAction SilentlyContinue
|
| } catch {
|
| if ($prevEAP) { $ErrorActionPreference = $prevEAP }
|
| Pop-Location
|
| throw
|
| } finally {
|
|
|
|
|
|
|
| $env:CSC_IDENTITY_AUTO_DISCOVERY = $prevCSCAuto
|
| $env:WIN_CSC_LINK = $prevWinCscLink
|
| $env:WIN_CSC_KEY_PASSWORD = $prevWinCscKeyPassword
|
| }
|
| Pop-Location
|
|
|
|
|
|
|
| $exeCandidates = @(
|
| "$desktopDir\release\win-unpacked\Hermes.exe",
|
| "$desktopDir\release\win-arm64-unpacked\Hermes.exe"
|
| )
|
| $found = $false
|
| $desktopExe = $null
|
| foreach ($cand in $exeCandidates) {
|
| if (Test-Path $cand) {
|
| Write-Success "Desktop ready: $cand"
|
| $desktopExe = $cand
|
| $found = $true
|
| break
|
| }
|
| }
|
| if (-not $found) {
|
| throw "Desktop build completed but no Hermes.exe was found under $desktopDir\release\*-unpacked\"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| $appDir = Split-Path -Parent $desktopExe
|
| & icacls $appDir /grant "*S-1-15-2-2:(OI)(CI)(RX)" /T /C /Q | Out-Null
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success "Granted AppContainer read access on $appDir"
|
| } else {
|
| Write-Warn "icacls AppContainer grant returned exit $LASTEXITCODE for $appDir"
|
| }
|
| } catch {
|
| Write-Warn "Could not grant AppContainer ACL: $($_.Exception.Message)"
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| New-DesktopShortcuts -TargetExe $desktopExe
|
| }
|
|
|
| function New-DesktopShortcuts {
|
| param([Parameter(Mandatory = $true)][string]$TargetExe)
|
|
|
|
|
| try {
|
| $shell = New-Object -ComObject WScript.Shell
|
| $workDir = Split-Path -Parent $TargetExe
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $iconIco = Join-Path $workDir 'resources\icon.ico'
|
| if (Test-Path $iconIco) {
|
| $iconLocation = "$iconIco,0"
|
| } else {
|
| $iconLocation = "$TargetExe,0"
|
| }
|
|
|
| $targets = @(
|
| (Join-Path ([Environment]::GetFolderPath('Programs')) 'Hermes.lnk'),
|
| (Join-Path ([Environment]::GetFolderPath('Desktop')) 'Hermes.lnk')
|
| )
|
|
|
| foreach ($lnkPath in $targets) {
|
| try {
|
| $parent = Split-Path -Parent $lnkPath
|
| if (-not (Test-Path $parent)) {
|
| New-Item -ItemType Directory -Force -Path $parent | Out-Null
|
| }
|
| $sc = $shell.CreateShortcut($lnkPath)
|
| $sc.TargetPath = $TargetExe
|
| $sc.WorkingDirectory = $workDir
|
| $sc.IconLocation = $iconLocation
|
| $sc.Description = 'Hermes Agent'
|
| $sc.Save()
|
| Write-Success "Shortcut created: $lnkPath"
|
| } catch {
|
| Write-Warn "Could not create shortcut $lnkPath : $($_.Exception.Message)"
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| try {
|
| & ie4uinit.exe -show 2>$null
|
| } catch {
|
|
|
| }
|
| } catch {
|
| Write-Warn "Skipping shortcut creation: $($_.Exception.Message)"
|
| }
|
| }
|
|
|
| function Install-PlatformSdks {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($NoVenv) {
|
| Write-Info "Skipping platform-SDK verification (-NoVenv: no venv to bootstrap)"
|
| return
|
| }
|
|
|
| $pythonExe = "$InstallDir\venv\Scripts\python.exe"
|
| if (-not (Test-Path $pythonExe)) {
|
| Write-Warn "Skipping platform-SDK verification: $pythonExe not found"
|
| return
|
| }
|
|
|
| $envPath = "$HermesHome\.env"
|
| if (-not (Test-Path $envPath)) { return }
|
| $envLines = Get-Content $envPath -ErrorAction SilentlyContinue
|
|
|
|
|
|
|
| $sdkMap = @(
|
| @{ Var = "TELEGRAM_BOT_TOKEN"; Import = "telegram"; Spec = "python-telegram-bot[webhooks]>=22.6,<23" },
|
| @{ Var = "DISCORD_BOT_TOKEN"; Import = "discord"; Spec = "discord.py[voice]>=2.7.1,<3" },
|
| @{ Var = "SLACK_BOT_TOKEN"; Import = "slack_sdk"; Spec = "slack-sdk>=3.27.0,<4" },
|
| @{ Var = "SLACK_APP_TOKEN"; Import = "slack_bolt";Spec = "slack-bolt>=1.18.0,<2" },
|
| @{ Var = "WHATSAPP_ENABLED"; Import = "qrcode"; Spec = "qrcode>=7.0,<8" }
|
| )
|
|
|
|
|
| $needed = @()
|
| foreach ($sdk in $sdkMap) {
|
| $match = $envLines | Where-Object {
|
| $_ -match ("^" + [regex]::Escape($sdk.Var) + "=.+") `
|
| -and $_ -notmatch "your-token-here" `
|
| -and $_ -notmatch "^\s*#"
|
| }
|
| if ($match) { $needed += $sdk }
|
| }
|
| if ($needed.Count -eq 0) { return }
|
|
|
| Write-Host ""
|
| Write-Info "Verifying platform SDKs for tokens found in $envPath ..."
|
|
|
|
|
|
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "SilentlyContinue"
|
| try {
|
| $missing = @()
|
| foreach ($sdk in $needed) {
|
| & $pythonExe -c "import $($sdk.Import)" 2>&1 | Out-Null
|
| if ($LASTEXITCODE -ne 0) {
|
| $missing += $sdk
|
| Write-Warn " $($sdk.Import) NOT importable (needed for $($sdk.Var))"
|
| } else {
|
| Write-Success " $($sdk.Import) OK"
|
| }
|
| }
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| }
|
| if ($missing.Count -eq 0) { return }
|
|
|
|
|
|
|
| $prevEAP = $ErrorActionPreference
|
| $ErrorActionPreference = "SilentlyContinue"
|
| try {
|
| & $pythonExe -m pip --version 2>&1 | Out-Null
|
| if ($LASTEXITCODE -ne 0) {
|
| Write-Info "Bootstrapping pip into venv (uv doesn't ship pip)..."
|
| & $pythonExe -m ensurepip --upgrade 2>&1 | Out-Null
|
| if ($LASTEXITCODE -ne 0) {
|
| Write-Warn "ensurepip failed -- can't auto-install missing SDKs."
|
| Write-Info "Manual recovery: $UvCmd pip install `"$($missing[0].Spec)`""
|
| return
|
| }
|
| }
|
|
|
| foreach ($sdk in $missing) {
|
| Write-Info " Installing $($sdk.Spec) ..."
|
| & $pythonExe -m pip install $sdk.Spec 2>&1 | ForEach-Object { Write-Host " $_" }
|
| if ($LASTEXITCODE -eq 0) {
|
| Write-Success " Installed $($sdk.Import)"
|
| } else {
|
| Write-Warn " Failed to install $($sdk.Spec). Recover manually: $pythonExe -m pip install `"$($sdk.Spec)`""
|
| }
|
| }
|
| } finally {
|
| $ErrorActionPreference = $prevEAP
|
| }
|
| }
|
|
|
| function Invoke-SetupWizard {
|
| if ($SkipSetup) {
|
| Write-Info "Skipping setup wizard (-SkipSetup)"
|
| return
|
| }
|
|
|
| if ($NonInteractive) {
|
|
|
|
|
|
|
| Write-Info "Skipping setup wizard (non-interactive). Configure via the GUI or 'hermes setup'."
|
| return
|
| }
|
|
|
| Write-Host ""
|
| Write-Info "Starting setup wizard..."
|
| Write-Host ""
|
|
|
| Push-Location $InstallDir
|
|
|
|
|
| if (-not $NoVenv) {
|
| & ".\venv\Scripts\python.exe" -m hermes_cli.main setup
|
| } else {
|
| python -m hermes_cli.main setup
|
| }
|
|
|
| Pop-Location
|
| }
|
|
|
| function Start-GatewayIfConfigured {
|
| $envPath = "$HermesHome\.env"
|
| if (-not (Test-Path $envPath)) { return }
|
|
|
| $hasMessaging = $false
|
| $content = Get-Content $envPath -ErrorAction SilentlyContinue
|
| foreach ($var in @("TELEGRAM_BOT_TOKEN", "DISCORD_BOT_TOKEN", "SLACK_BOT_TOKEN", "SLACK_APP_TOKEN", "WHATSAPP_ENABLED")) {
|
| $match = $content | Where-Object { $_ -match "^${var}=.+" -and $_ -notmatch "your-token-here" }
|
| if ($match) { $hasMessaging = $true; break }
|
| }
|
|
|
| if (-not $hasMessaging) { return }
|
|
|
| $hermesCmd = "$InstallDir\venv\Scripts\hermes.exe"
|
| if (-not (Test-Path $hermesCmd)) {
|
| $hermesCmd = "hermes"
|
| }
|
|
|
|
|
| $whatsappEnabled = $content | Where-Object { $_ -match "^WHATSAPP_ENABLED=true" }
|
| $whatsappSession = "$HermesHome\whatsapp\session\creds.json"
|
| if ($whatsappEnabled -and -not (Test-Path $whatsappSession)) {
|
| Write-Host ""
|
| Write-Info "WhatsApp is enabled but not yet paired."
|
| Write-Info "Running 'hermes whatsapp' to pair via QR code..."
|
| Write-Host ""
|
|
|
|
|
|
|
| if (-not $NonInteractive) {
|
| $response = Read-Host "Pair WhatsApp now? [Y/n]"
|
| if ($response -eq "" -or $response -match "^[Yy]") {
|
| try {
|
| & $hermesCmd whatsapp
|
| } catch {
|
|
|
| }
|
| }
|
| } else {
|
| Write-Info "Skipping WhatsApp pairing prompt (non-interactive)."
|
| }
|
| }
|
|
|
| Write-Host ""
|
| Write-Info "Messaging platform token detected!"
|
| Write-Info "The gateway handles messaging platforms and cron job execution."
|
| Write-Host ""
|
|
|
|
|
|
|
|
|
| if ($NonInteractive) {
|
| Write-Info "Skipping gateway autostart prompt (non-interactive)."
|
| Write-Info "Start the gateway later with: hermes gateway"
|
| return
|
| }
|
|
|
| $response = Read-Host "Would you like to start the gateway now? [Y/n]"
|
|
|
| if ($response -eq "" -or $response -match "^[Yy]") {
|
| Write-Info "Starting gateway in background..."
|
| try {
|
| $logFile = "$HermesHome\logs\gateway.log"
|
| Start-Process -FilePath $hermesCmd -ArgumentList "gateway" `
|
| -RedirectStandardOutput $logFile `
|
| -RedirectStandardError "$HermesHome\logs\gateway-error.log" `
|
| -WindowStyle Hidden
|
| Write-Success "Gateway started! Your bot is now online."
|
| Write-Info "Logs: $logFile"
|
| Write-Info "To stop: close the gateway process from Task Manager"
|
| } catch {
|
| Write-Warn "Failed to start gateway. Run manually: hermes gateway"
|
| }
|
| } else {
|
| Write-Info "Skipped. Start the gateway later with: hermes gateway"
|
| }
|
| }
|
|
|
| function Write-Completion {
|
| Write-Host ""
|
| Write-Host "+---------------------------------------------------------+" -ForegroundColor Green
|
| Write-Host "| [OK] Installation Complete! |" -ForegroundColor Green
|
| Write-Host "+---------------------------------------------------------+" -ForegroundColor Green
|
| Write-Host ""
|
|
|
|
|
| Write-Host "* Your files:" -ForegroundColor Cyan
|
| Write-Host ""
|
| Write-Host " Config: " -NoNewline -ForegroundColor Yellow
|
| Write-Host "$HermesHome\config.yaml"
|
| Write-Host " API Keys: " -NoNewline -ForegroundColor Yellow
|
| Write-Host "$HermesHome\.env"
|
| Write-Host " Data: " -NoNewline -ForegroundColor Yellow
|
| Write-Host "$HermesHome\cron\, sessions\, logs\"
|
| Write-Host " Code: " -NoNewline -ForegroundColor Yellow
|
| Write-Host "$HermesHome\hermes-agent\"
|
| Write-Host ""
|
|
|
| Write-Host "---------------------------------------------------------" -ForegroundColor Cyan
|
| Write-Host ""
|
| Write-Host "* Commands:" -ForegroundColor Cyan
|
| Write-Host ""
|
| Write-Host " hermes " -NoNewline -ForegroundColor Green
|
| Write-Host "Start chatting"
|
| Write-Host " hermes setup " -NoNewline -ForegroundColor Green
|
| Write-Host "Configure API keys & settings"
|
| Write-Host " hermes config " -NoNewline -ForegroundColor Green
|
| Write-Host "View/edit configuration"
|
| Write-Host " hermes config edit " -NoNewline -ForegroundColor Green
|
| Write-Host "Open config in editor"
|
| Write-Host " hermes gateway " -NoNewline -ForegroundColor Green
|
| Write-Host "Start messaging gateway (Telegram, Discord, etc.)"
|
| Write-Host " hermes update " -NoNewline -ForegroundColor Green
|
| Write-Host "Update to latest version"
|
| Write-Host ""
|
|
|
| Write-Host "---------------------------------------------------------" -ForegroundColor Cyan
|
| Write-Host ""
|
| Write-Host "[*] Restart your terminal for PATH changes to take effect" -ForegroundColor Yellow
|
| Write-Host ""
|
|
|
| if (-not $HasNode) {
|
| Write-Host "Note: Node.js could not be installed automatically." -ForegroundColor Yellow
|
| Write-Host "Browser tools need Node.js. Install manually:" -ForegroundColor Yellow
|
| Write-Host " https://nodejs.org/en/download/" -ForegroundColor Yellow
|
| Write-Host ""
|
| }
|
|
|
| if (-not $HasRipgrep) {
|
| Write-Host "Note: ripgrep (rg) was not installed. For faster file search:" -ForegroundColor Yellow
|
| Write-Host " winget install BurntSushi.ripgrep.MSVC" -ForegroundColor Yellow
|
| Write-Host ""
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $InstallStages = @(
|
| @{ Name = "uv"; Title = "Installing uv package manager"; Category = "prereqs"; NeedsUserInput = $false; Worker = "Stage-Uv" }
|
| @{ Name = "git"; Title = "Installing Git"; Category = "prereqs"; NeedsUserInput = $false; Worker = "Stage-Git" }
|
| @{ Name = "node"; Title = "Detecting Node.js"; Category = "prereqs"; NeedsUserInput = $false; Worker = "Stage-Node" }
|
| @{ Name = "system-packages"; Title = "Installing ripgrep and ffmpeg"; Category = "prereqs"; NeedsUserInput = $false; Worker = "Stage-SystemPackages" }
|
| @{ Name = "repository"; Title = "Cloning Hermes repository"; Category = "install"; NeedsUserInput = $false; Worker = "Stage-Repository" }
|
|
|
|
|
|
|
|
|
| @{ Name = "python"; Title = "Verifying Python $PythonVersion"; Category = "prereqs"; NeedsUserInput = $false; Worker = "Stage-Python" }
|
| @{ Name = "venv"; Title = "Creating Python virtual environment"; Category = "install"; NeedsUserInput = $false; Worker = "Stage-Venv" }
|
| @{ Name = "dependencies"; Title = "Installing Python dependencies"; Category = "install"; NeedsUserInput = $false; Worker = "Stage-Dependencies" }
|
| @{ Name = "node-deps"; Title = "Installing Node.js dependencies"; Category = "install"; NeedsUserInput = $false; Worker = "Stage-NodeDeps" }
|
| )
|
| if ($IncludeDesktop) {
|
|
|
|
|
|
|
| $InstallStages += @{ Name = "desktop"; Title = "Building desktop app"; Category = "install"; NeedsUserInput = $false; Worker = "Stage-Desktop" }
|
| }
|
| $InstallStages += @(
|
| @{ Name = "path"; Title = "Adding Hermes to PATH"; Category = "finalize"; NeedsUserInput = $false; Worker = "Stage-Path" }
|
| @{ Name = "config-templates"; Title = "Writing configuration templates"; Category = "finalize"; NeedsUserInput = $false; Worker = "Stage-ConfigTemplates" }
|
| @{ Name = "platform-sdks"; Title = "Installing messaging platform SDKs"; Category = "finalize"; NeedsUserInput = $false; Worker = "Stage-PlatformSdks" }
|
| @{ Name = "bootstrap-marker"; Title = "Marking install complete"; Category = "finalize"; NeedsUserInput = $false; Worker = "Stage-BootstrapMarker" }
|
|
|
|
|
| @{ Name = "configure"; Title = "Configuring API keys and models"; Category = "post-install"; NeedsUserInput = $true; Worker = "Stage-Configure" }
|
| @{ Name = "gateway"; Title = "Starting messaging gateway"; Category = "post-install"; NeedsUserInput = $true; Worker = "Stage-Gateway" }
|
| )
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Stage-Uv { if (-not (Install-Uv)) { throw "uv installation failed" } }
|
| function Stage-Python { Resolve-UvCmd; if (-not (Test-Python)) { throw "Python $PythonVersion not available" } }
|
| function Stage-Git {
|
| if (-not (Install-Git)) {
|
| if ($script:GitInstallFailureReason) { throw $script:GitInstallFailureReason }
|
| throw "Git not available and auto-install failed -- install from https://git-scm.com/download/win then re-run"
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| function Stage-Node {
|
| if (-not (Test-Node)) {
|
| $script:_StageSkippedReason = "Node.js not available; browser tools will be unavailable until node is installed manually from https://nodejs.org/en/download/"
|
| }
|
| }
|
| function Stage-SystemPackages { Install-SystemPackages }
|
| function Stage-Repository { Install-Repository }
|
| function Stage-Venv { Resolve-UvCmd; Install-Venv }
|
| function Stage-Dependencies { Resolve-UvCmd; Install-Dependencies }
|
| function Stage-NodeDeps { Install-NodeDeps }
|
| function Stage-Desktop { Install-DesktopVoiceDeps; Install-Desktop }
|
| function Stage-Path { Set-PathVariable }
|
| function Stage-ConfigTemplates { Copy-ConfigTemplates }
|
| function Stage-PlatformSdks { Resolve-UvCmd; Install-PlatformSdks }
|
| function Stage-BootstrapMarker { Write-BootstrapMarker }
|
| function Stage-Configure { Invoke-SetupWizard }
|
| function Stage-Gateway { Start-GatewayIfConfigured }
|
|
|
| function Get-InstallStage {
|
| param([string]$Name)
|
| foreach ($s in $InstallStages) {
|
| if ($s.Name -eq $Name) { return $s }
|
| }
|
| return $null
|
| }
|
|
|
| function Step-OutOfInstallDir {
|
|
|
|
|
|
|
|
|
| try {
|
| $currentResolved = (Get-Location).ProviderPath
|
| $installResolved = $null
|
| if (Test-Path $InstallDir) {
|
| $installResolved = (Resolve-Path $InstallDir -ErrorAction SilentlyContinue).ProviderPath
|
| }
|
| if ($installResolved -and $currentResolved.ToLower().StartsWith($installResolved.ToLower())) {
|
| Write-Info "Stepping out of $InstallDir so Windows can replace files there if needed..."
|
| Set-Location $env:USERPROFILE
|
| }
|
| } catch {}
|
| }
|
|
|
| function Invoke-Stage {
|
| param(
|
| [Parameter(Mandatory=$true)] [hashtable]$StageDef
|
| )
|
|
|
|
|
|
|
|
|
|
|
| Sync-EnvPath
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| $script:_StageSkippedReason = $null
|
|
|
| $start = [DateTime]::UtcNow
|
| $result = @{
|
| stage = $StageDef.Name
|
| ok = $false
|
| skipped = $false
|
| reason = $null
|
| duration_ms = 0
|
| }
|
|
|
| try {
|
| & $StageDef.Worker
|
| $result.ok = $true
|
| if ($script:_StageSkippedReason) {
|
| $result.skipped = $true
|
| $result.reason = $script:_StageSkippedReason
|
| }
|
| } catch {
|
| $result.ok = $false
|
| $result.reason = "$_"
|
| throw
|
| } finally {
|
| $result.duration_ms = [int]([DateTime]::UtcNow - $start).TotalMilliseconds
|
| if ($Json -or $Stage) {
|
|
|
|
|
|
|
| $result | ConvertTo-Json -Compress | Write-Output
|
|
|
|
|
|
|
|
|
| if (-not $result.ok) {
|
| $script:_StageEmittedErrorFrame = $true
|
| }
|
| }
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
| function Invoke-AllStages {
|
| Step-OutOfInstallDir
|
| foreach ($s in $InstallStages) {
|
| Invoke-Stage -StageDef $s
|
| }
|
| }
|
|
|
| function Invoke-EnsureMode {
|
| param([string]$Deps)
|
| $depList = $Deps -split ","
|
| foreach ($dep in $depList) {
|
| $dep = $dep.Trim()
|
| switch ($dep) {
|
| "node" {
|
| [void](Test-Node)
|
| if (-not $script:HasNode) {
|
| Write-Err "Node.js could not be installed"
|
| exit 1
|
| }
|
| }
|
| "browser" {
|
| [void](Test-Node)
|
| if ($script:HasNode) {
|
| Install-AgentBrowser
|
| } else {
|
| Write-Err "Node.js is required for browser tools but could not be installed"
|
| exit 1
|
| }
|
| }
|
| "ripgrep" {
|
| Write-Info "ripgrep: install manually on Windows (scoop install ripgrep)"
|
| }
|
| "ffmpeg" {
|
| Write-Info "ffmpeg: install manually on Windows (scoop install ffmpeg)"
|
| }
|
| default {
|
| Write-Err "Unknown dependency: $dep"
|
| exit 1
|
| }
|
| }
|
| }
|
| }
|
|
|
| function Invoke-PostInstallMode {
|
| Write-Info "Running post-install setup..."
|
| Invoke-EnsureMode -Deps "node,browser"
|
| Write-Info "Post-install complete"
|
| }
|
|
|
| function Main {
|
| Write-Banner
|
| Invoke-AllStages
|
| if (-not $Json) {
|
| Write-Completion
|
| } else {
|
| @{ ok = $true; protocol_version = $InstallStageProtocolVersion } | ConvertTo-Json -Compress | Write-Output
|
| }
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($MyInvocation.InvocationName -eq ".") {
|
| return
|
| }
|
|
|
| try {
|
| if ($Ensure -ne "") {
|
| if ($PSBoundParameters.ContainsKey("Stage")) {
|
| Write-Err "Cannot use -Ensure and -Stage simultaneously"
|
| exit 1
|
| }
|
| Invoke-EnsureMode -Deps $Ensure
|
| exit 0
|
| }
|
| if ($PostInstall) {
|
| Invoke-PostInstallMode
|
| exit 0
|
| }
|
|
|
| if ($ProtocolVersion) {
|
| Write-Output $InstallStageProtocolVersion
|
| exit 0
|
| }
|
|
|
| if ($ShowResolvedPaths) {
|
| $script:ResolvedPathReport | ConvertTo-Json -Depth 5 -Compress | Write-Output
|
| exit 0
|
| }
|
|
|
| if ($Manifest) {
|
| $payload = @{
|
| protocol_version = $InstallStageProtocolVersion
|
| stages = @($InstallStages | ForEach-Object {
|
| @{
|
| name = $_.Name
|
| title = $_.Title
|
| category = $_.Category
|
| needs_user_input = $_.NeedsUserInput
|
| }
|
| })
|
| }
|
| $payload | ConvertTo-Json -Depth 5 -Compress | Write-Output
|
| exit 0
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| if ($PSBoundParameters.ContainsKey("Stage")) {
|
| $def = Get-InstallStage -Name $Stage
|
| if (-not $def) {
|
| $err = @{
|
| ok = $false
|
| stage = $Stage
|
| reason = "unknown stage: $Stage. Run install.ps1 -Manifest to list valid stages."
|
| }
|
| $err | ConvertTo-Json -Compress | Write-Output
|
| exit 2
|
| }
|
| Step-OutOfInstallDir
|
| Invoke-Stage -StageDef $def
|
| exit 0
|
| }
|
|
|
|
|
|
|
| Main
|
| } catch {
|
| if ($Json -or $Stage) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| if (-not $script:_StageEmittedErrorFrame) {
|
| $err = @{
|
| ok = $false
|
| stage = if ($Stage) { $Stage } else { $null }
|
| reason = "$_"
|
| }
|
| $err | ConvertTo-Json -Compress | Write-Output
|
| }
|
| exit 1
|
| }
|
|
|
|
|
| Write-Host ""
|
| Write-Err "Installation failed: $_"
|
| Write-Host ""
|
| Write-Info "If the error is unclear, try downloading and running the script directly:"
|
| Write-Host " Invoke-WebRequest -Uri 'https://hermes-agent.nousresearch.com/install.ps1' -OutFile install.ps1" -ForegroundColor Yellow
|
| Write-Host " .\install.ps1" -ForegroundColor Yellow
|
| Write-Host ""
|
| }
|
|
|
