@cats-inc/cats-platform 0.1.10 → 0.2.8

package/scripts/windows/{Install-Aider.ps1 → Install-MetaCli.ps1}

@@ -1,17 +1,27 @@
 <#
 .SYNOPSIS
-    Install or verify the native Windows Aider for Cats.
+    Install or verify the native Windows Meta Muse CLI for Cats.
 
 .DESCRIPTION
-    Cats-owned packaged setup wrapper for Aider. The official installer is the
-    uv installer plus `uv tool install --force --python python3.12 --with pip
-    aider-chat@latest`, so the entry point at %USERPROFILE%\.local\bin\aider.exe
-    is a uv tool shim rather than the tool itself. Uninstall therefore runs
-    `uv tool uninstall aider-chat` before removing paths.
-
-    Cats installs and detects Aider but cannot run sessions through it: 0.86.2
-    has no machine-readable output, no ACP or server mode, and exits 0 even when
-    the model call fails.
+    Cats-owned packaged setup wrapper for Meta's Muse CLI. The official
+    installer at https://dev.meta.ai/install.ps1 writes a muse.cmd shim plus
+    .muse-launcher.ps1 into %LOCALAPPDATA%\Programs\muse (overridable with
+    MUSE_INSTALL_DIR) and adds that directory to the User PATH. The launcher
+    then downloads the actual agent, muse-bin-<version>.exe, beside itself and
+    records the version in .muse-version.
+
+    Two consequences drive this helper.
+
+    Detection requires the binary, not the shim. The installer writes the shim
+    and launcher first and downloads the agent last, so a run that fails in
+    between leaves a shim with nothing behind it. Reporting that as installed
+    would skip the reinstall that repairs it.
+
+    The version is read from .muse-version and `muse` is never executed. The
+    launcher forwards every argument straight to the agent binary, so a flag
+    that binary does not recognise opens the interactive TUI instead of
+    failing -- which in packaged setup, with no console a prompt can reach, is
+    an unbounded hang rather than an error.
 #>
 param(
   [switch]$CheckOnly,
@@ -55,89 +65,167 @@ function Write-StructuredResult {
   exit $ExitCode
 }
 
-function Resolve-AiderInstallDir {
-  return Join-Path $env:USERPROFILE '.local\bin'
+function Resolve-MuseInstallDir {
+  if (-not [string]::IsNullOrWhiteSpace($env:MUSE_INSTALL_DIR)) {
+    return $env:MUSE_INSTALL_DIR
+  }
+  return Join-Path $env:LOCALAPPDATA 'Programs\muse'
+}
+
+function Resolve-MuseShimPath {
+  return Join-Path (Resolve-MuseInstallDir) 'muse.cmd'
+}
+
+function Resolve-MuseLauncherPath {
+  return Join-Path (Resolve-MuseInstallDir) '.muse-launcher.ps1'
+}
+
+function Resolve-MuseVersionFilePath {
+  return Join-Path (Resolve-MuseInstallDir) '.muse-version'
+}
+
+function Get-MuseRecordedVersion {
+  $versionFile = Resolve-MuseVersionFilePath
+  if (-not (Test-Path -LiteralPath $versionFile -PathType Leaf)) { return '' }
+  try {
+    $version = (Get-Content -LiteralPath $versionFile -Raw -ErrorAction Stop).Trim()
+    if ([string]::IsNullOrWhiteSpace($version)) { return '' }
+    return $version
+  } catch {
+    return ''
+  }
 }
 
-function Resolve-AiderExecutablePath {
-  return Join-Path (Resolve-AiderInstallDir) 'aider.exe'
+function Get-MuseAgentBinaryPath {
+  $version = Get-MuseRecordedVersion
+  if ([string]::IsNullOrWhiteSpace($version)) { return '' }
+  return Join-Path (Resolve-MuseInstallDir) "muse-bin-$version.exe"
 }
 
-function Refresh-UserPath {
+# Everything the launcher owns in the install directory, so uninstall does not
+# leave gigabytes of downloaded agent builds behind after removing the shim.
+function Get-MuseOwnedPaths {
+  $installDir = Resolve-MuseInstallDir
+  $paths = [System.Collections.Generic.List[string]]::new()
+  $paths.Add((Resolve-MuseLauncherPath)) | Out-Null
+  if (-not (Test-Path -LiteralPath $installDir -PathType Container)) {
+    return $paths.ToArray()
+  }
+  foreach ($pattern in @('muse-bin-*.exe', '.muse-*')) {
+    foreach ($item in Get-ChildItem -LiteralPath $installDir -Filter $pattern -Force -ErrorAction SilentlyContinue) {
+      if (-not $paths.Contains($item.FullName)) {
+        $paths.Add($item.FullName) | Out-Null
+      }
+    }
+  }
+  return $paths.ToArray()
+}
+
+function Update-UserPathEnvironment {
   $env:Path = [System.Environment]::GetEnvironmentVariable('Path', 'User') + ';' +
     [System.Environment]::GetEnvironmentVariable('Path', 'Machine')
 }
 
-function Detect-AiderInstall {
-  $exePath = Resolve-AiderExecutablePath
+function Get-MuseInstallState {
+  $shimPath = Resolve-MuseShimPath
 
   if ($InstallState -eq 'installed') {
     return [pscustomobject]@{
       installed = $true
-      commandPath = $exePath
+      commandPath = $shimPath
       detectedVersion = $DetectedVersion
+      partial = $false
     }
   }
   if ($InstallState -eq 'missing') {
     return [pscustomobject]@{
       installed = $false
-      commandPath = $exePath
+      commandPath = $shimPath
       detectedVersion = $DetectedVersion
+      partial = $false
     }
   }
 
-  Refresh-UserPath
-  $command = Get-Command aider -ErrorAction SilentlyContinue
-  $installed = $null -ne $command -or (Test-Path -LiteralPath $exePath -PathType Leaf)
-  $commandPath = if ($null -ne $command) { $command.Source } else { $exePath }
-  $commandSource = if ($null -ne $command) { $command.Source } else { '' }
-  $version = $DetectedVersion
-  $versionProbePath = Resolve-HiddenVersionProbePath `
-    -PreferredPath $commandSource `
-    -FallbackPath $exePath
-
-  if ($installed -and [string]::IsNullOrWhiteSpace($version) -and $versionProbePath) {
-    try {
-      $version = Get-HiddenCommandText -FileName $versionProbePath -ArgumentList @('--version')
-    } catch {
-      $version = ''
+  Update-UserPathEnvironment
+  $version = if ([string]::IsNullOrWhiteSpace($DetectedVersion)) {
+    Get-MuseRecordedVersion
+  } else {
+    $DetectedVersion
+  }
+
+  $shimPresent = Test-Path -LiteralPath $shimPath -PathType Leaf
+  $agentBinary = Get-MuseAgentBinaryPath
+  $agentPresent = (-not [string]::IsNullOrWhiteSpace($agentBinary)) -and
+    (Test-Path -LiteralPath $agentBinary -PathType Leaf)
+
+  if ($shimPresent -and $agentPresent) {
+    return [pscustomobject]@{
+      installed = $true
+      commandPath = $shimPath
+      detectedVersion = $version
+      partial = $false
+    }
+  }
+
+  if ($shimPresent) {
+    # Shim without an agent build: the last install died partway through.
+    return [pscustomobject]@{
+      installed = $false
+      commandPath = $shimPath
+      detectedVersion = $version
+      partial = $true
+    }
+  }
+
+  # Nothing in the expected directory, but the operator may have muse elsewhere.
+  $command = Get-Command muse -ErrorAction SilentlyContinue
+  if ($null -ne $command) {
+    return [pscustomobject]@{
+      installed = $true
+      commandPath = $command.Source
+      detectedVersion = $version
+      partial = $false
     }
   }
 
   return [pscustomobject]@{
-    installed = $installed
-    commandPath = $commandPath
+    installed = $false
+    commandPath = $shimPath
     detectedVersion = $version
+    partial = $false
   }
 }
 
-function Add-AiderToUserPath {
-  $installDir = Resolve-AiderInstallDir
+function Add-MuseToUserPath {
+  $installDir = Resolve-MuseInstallDir
   $userPath = [System.Environment]::GetEnvironmentVariable('Path', 'User')
   if ([string]::IsNullOrWhiteSpace($userPath)) {
     [System.Environment]::SetEnvironmentVariable('Path', $installDir, 'User')
   } elseif ($userPath -notlike "*$installDir*") {
     [System.Environment]::SetEnvironmentVariable('Path', "$installDir;$userPath", 'User')
   }
-  Refresh-UserPath
+  Update-UserPathEnvironment
 }
 
-function Invoke-AiderInstaller {
+function Invoke-MuseInstaller {
   if ($SkipInstaller) {
     return [pscustomobject]@{ skipped = $true; success = $true; exitCode = 0; stderr = '' }
   }
 
   $tempScript = [System.IO.Path]::Combine(
     [System.IO.Path]::GetTempPath(),
-    "cats-aider-install-$([System.Guid]::NewGuid().ToString('N')).ps1"
+    "cats-muse-install-$([System.Guid]::NewGuid().ToString('N')).ps1"
   )
   $stdoutPath = "$tempScript.stdout"
   $stderrPath = "$tempScript.stderr"
+  # The official install.ps1 opens with Set-StrictMode -Version Latest and calls
+  # exit 1 on failure, so it runs in its own process rather than taking this
+  # script down with it.
   $bootstrap = @'
 & {
   $previousErrorActionPreference = $ErrorActionPreference
   try {
-    Invoke-RestMethod 'https://aider.chat/install.ps1' | Invoke-Expression
+    Invoke-RestMethod 'https://dev.meta.ai/install.ps1' | Invoke-Expression
   } finally {
     $ErrorActionPreference = $previousErrorActionPreference
   }
@@ -150,11 +238,10 @@ function Invoke-AiderInstaller {
       $bootstrap,
       [System.Text.UTF8Encoding]::new($false)
     )
-    $powerShellExe = if (Get-Command pwsh.exe -ErrorAction SilentlyContinue) {
-      'pwsh.exe'
-    } else {
-      'powershell.exe'
-    }
+    # The muse launcher runs under Windows PowerShell 5.1. A PSModulePath
+    # inherited from PowerShell 7 breaks its download step and leaves a shim
+    # with no agent build, so the installer is run under 5.1 as well.
+    $powerShellExe = 'powershell.exe'
     $process = Start-Process -FilePath $powerShellExe `
       -ArgumentList @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $tempScript) `
       -Wait -PassThru -NoNewWindow `
@@ -175,7 +262,7 @@ function Invoke-AiderInstaller {
       skipped = $false
       success = $false
       exitCode = -1
-      stderr = "Failed to invoke Aider installer: $($_.Exception.Message)"
+      stderr = "Failed to invoke Meta Muse installer: $($_.Exception.Message)"
     }
   } finally {
     foreach ($path in @($tempScript, $stdoutPath, $stderrPath)) {
@@ -192,13 +279,13 @@ if (-not $CheckOnly -and -not $Apply -and -not $Upgrade -and -not $Force -and -n
 
 $mutationCount = @($Apply, $Upgrade, $Force | Where-Object { $_ }).Count
 if ($Uninstall -and ($CheckOnly -or $mutationCount -gt 0)) {
-  throw 'Install-Aider.ps1 -Uninstall is mutually exclusive with other modes.'
+  throw 'Install-MetaCli.ps1 -Uninstall is mutually exclusive with other modes.'
 }
 if ($CheckOnly -and $mutationCount -gt 0) {
-  throw 'Install-Aider.ps1 accepts either -CheckOnly or one mutation mode.'
+  throw 'Install-MetaCli.ps1 accepts either -CheckOnly or one mutation mode.'
 }
 if ($mutationCount -gt 1) {
-  throw 'Install-Aider.ps1 accepts at most one of -Apply / -Upgrade / -Force.'
+  throw 'Install-MetaCli.ps1 accepts at most one of -Apply / -Upgrade / -Force.'
 }
 
 $executionMode = if ($Uninstall) {
@@ -214,24 +301,11 @@ $executionMode = if ($Uninstall) {
 }
 
 if ($Uninstall) {
-  # %USERPROFILE%\.local\bin\aider.exe is a uv tool shim, not the tool.
-  # Removing only the shim leaves aider-chat installed in the uv tool
-  # environment, so uv uninstalls it first and path removal mops up the rest.
-  #
-  # The uv binary itself is deliberately left alone: Aider's installer drops its
-  # own uv next to the shim, users commonly have another, and the helper cannot
-  # tell them apart (SPEC-112 PD4).
-  if (-not $DryRun) {
-    if (Get-Command uv -ErrorAction SilentlyContinue) {
-      & uv tool uninstall aider-chat 2>$null | Out-Null
-    }
-  }
-
   Invoke-PackagedProviderUninstall `
-    -HelperId 'windows-aider-native-installer' `
-    -UserBinaryPath (Resolve-AiderExecutablePath) `
-    -ExtraUserOwnedPaths @() `
-    -RedetectCommand { Detect-AiderInstall } `
+    -HelperId 'windows-muse-native-installer' `
+    -UserBinaryPath (Resolve-MuseShimPath) `
+    -ExtraUserOwnedPaths (Get-MuseOwnedPaths) `
+    -RedetectCommand { Get-MuseInstallState } `
     -EmitJson:$Json `
     -DryRun:$DryRun
 }
@@ -240,38 +314,42 @@ $isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIden
   IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
 if ($isAdmin -and -not $AllowAdmin) {
   Write-StructuredResult -Result ([pscustomobject]@{
-      helper = 'windows-aider-native-installer'
+      helper = 'windows-muse-native-installer'
       mode = $executionMode
       status = 'failed'
       installed = $false
       detectedVersion = $null
-      commandPath = Resolve-AiderExecutablePath
+      commandPath = Resolve-MuseShimPath
       restartRequired = $false
       plannedActions = @()
-      warnings = @('Refusing to run under an elevated shell without -AllowAdmin because Aider is intended for user-scoped installation.')
+      warnings = @('Refusing to run under an elevated shell without -AllowAdmin because Meta Muse CLI is intended for user-scoped installation.')
       appliedChanges = @()
       manualSteps = @()
       interruptions = @()
     }) -ExitCode 1
 }
 
-$detected = Detect-AiderInstall
+$detected = Get-MuseInstallState
 $plannedActions = [System.Collections.Generic.List[string]]::new()
 $appliedChanges = [System.Collections.Generic.List[string]]::new()
 $warnings = [System.Collections.Generic.List[string]]::new()
 $manualSteps = [System.Collections.Generic.List[string]]::new()
 
+if ($detected.partial) {
+  $warnings.Add('Found muse.cmd with no matching muse-bin-<version>.exe; the previous install did not finish and will be repaired.') | Out-Null
+}
+
 if ($Force) {
-  $plannedActions.Add('reinstall_aider_native')
+  $plannedActions.Add('reinstall_muse_native') | Out-Null
 } elseif ($Upgrade -and $detected.installed) {
-  $plannedActions.Add('upgrade_aider_native')
+  $plannedActions.Add('upgrade_muse_native') | Out-Null
 } elseif (-not $detected.installed) {
-  $plannedActions.Add('install_aider_native')
+  $plannedActions.Add('install_muse_native') | Out-Null
 }
 
 if ($CheckOnly) {
   Write-StructuredResult -Result ([pscustomobject]@{
-      helper = 'windows-aider-native-installer'
+      helper = 'windows-muse-native-installer'
       mode = 'check'
       status = if ($detected.installed) { 'ready' } else { 'not_installed' }
       installed = [bool]$detected.installed
@@ -279,7 +357,7 @@ if ($CheckOnly) {
       commandPath = $detected.commandPath
       restartRequired = $false
       plannedActions = $plannedActions.ToArray()
-      warnings = @()
+      warnings = $warnings.ToArray()
       appliedChanges = @()
       manualSteps = @()
       interruptions = @()
@@ -291,14 +369,15 @@ $installFailed = $false
 $installSkipped = $false
 if ($shouldInstall) {
   if ($DryRun) {
-    $warnings.Add('Dry-run requested; Aider installer invocation was skipped.')
+    $warnings.Add('Dry-run requested; Meta Muse installer invocation was skipped.') | Out-Null
     $installSkipped = $true
   } else {
-    $installResult = Invoke-AiderInstaller
+    $previousVersion = $detected.detectedVersion
+    $installResult = Invoke-MuseInstaller
     $installSkipped = [bool]$installResult.skipped
     $installFailed = (-not $installSkipped) -and (-not $installResult.success)
     if ($installSkipped) {
-      $warnings.Add('Installer invocation was skipped by request.')
+      $warnings.Add('Installer invocation was skipped by request.') | Out-Null
     } elseif ($installFailed) {
       $stderrSnippet = if ([string]::IsNullOrWhiteSpace($installResult.stderr)) {
         'no stderr captured'
@@ -307,39 +386,48 @@ if ($shouldInstall) {
           Where-Object { -not [string]::IsNullOrWhiteSpace($_) } |
           Select-Object -Last 8) -join ' | '
       }
-      $warnings.Add("Aider installer exited $($installResult.exitCode): $stderrSnippet")
+      $warnings.Add("Meta Muse installer exited $($installResult.exitCode): $stderrSnippet") | Out-Null
     }
 
-    Start-Sleep -Seconds 2
-    Add-AiderToUserPath
-    $detected = Detect-AiderInstall
+    Start-Sleep -Seconds 3
+    Add-MuseToUserPath
+    $detected = Get-MuseInstallState
     if (-not $detected.installed -and -not $installSkipped -and -not $installFailed) {
-      $warnings.Add('Aider installation completed but aider.exe was not detected at the expected path.')
+      if ($detected.partial) {
+        $warnings.Add('Meta Muse installation wrote muse.cmd but the launcher did not fetch muse-bin-<version>.exe.') | Out-Null
+      } else {
+        $warnings.Add('Meta Muse installation completed but muse.cmd was not found at the expected path.') | Out-Null
+      }
       $installFailed = $true
+    } elseif (
+      $Upgrade -and $detected.installed -and $previousVersion -and
+      $detected.detectedVersion -eq $previousVersion
+    ) {
+      $warnings.Add("Meta Muse CLI is already on the latest build: $($detected.detectedVersion).") | Out-Null
     }
   }
 
   if (-not $installFailed -and -not ($DryRun -and $shouldInstall)) {
     if ($Force) {
-      $appliedChanges.Add('reinstall_aider_native')
+      $appliedChanges.Add('reinstall_muse_native') | Out-Null
     } elseif ($Upgrade) {
-      $appliedChanges.Add('upgrade_aider_native')
+      $appliedChanges.Add('upgrade_muse_native') | Out-Null
     } else {
-      $appliedChanges.Add('install_aider_native')
+      $appliedChanges.Add('install_muse_native') | Out-Null
     }
   }
 }
 
-$manualSteps.Add('Run `aider login` or set XAI_API_KEY before first use.')
+$manualSteps.Add('Run `muse login` once to sign in to a Meta account; the credential is stored in ~/.config/muse/auth.json.') | Out-Null
 $interruptions = [System.Collections.Generic.List[object]]::new()
 if ($shouldInstall -and -not $installFailed -and -not $DryRun) {
   $interruptions.Add([pscustomobject]@{
       kind = 'relaunch_required'
-      summary = 'Relaunch Cats Desktop Host after the Aider install step, then rerun the packaged setup check.'
+      summary = 'Relaunch Cats Desktop Host after the Meta Muse install step, then rerun the packaged setup check.'
       resumable = $true
       requiresRestart = $false
       requiresElevation = $false
-    })
+    }) | Out-Null
 }
 
 $status = if ($installFailed) {
@@ -353,7 +441,7 @@ $status = if ($installFailed) {
 }
 
 Write-StructuredResult -Result ([pscustomobject]@{
-    helper = 'windows-aider-native-installer'
+    helper = 'windows-muse-native-installer'
     mode = $executionMode
     status = $status
     installed = [bool]$detected.installed

package/scripts/windows/Install-Ollama.ps1

@@ -146,7 +146,10 @@ function Detect-OllamaInstall {
 
   if ($installed -and [string]::IsNullOrWhiteSpace($version) -and $versionProbePath) {
     try {
-      $version = Get-HiddenCommandText -FileName $versionProbePath -ArgumentList @('--version')
+      # Detection must not launch a provider, including during login setup audits.
+      $versionInfo = [System.Diagnostics.FileVersionInfo]::GetVersionInfo($versionProbePath)
+      $version = $versionInfo.ProductVersion
+      if ([string]::IsNullOrWhiteSpace($version)) { $version = $versionInfo.FileVersion }
     } catch {
       $version = ''
     }