fix: enable Windows native auto-update

Windows native installs could rename a running exe but not overwrite it,
so the CLI hard-disabled auto-update on that platform and told users to
run install.ps1 by hand instead.

install.ps1 now stages the new binary inside the install dir and
replaces the running exe with a rename-aside-then-move sequence,
retrying cleanup of the old file for a few seconds since it may still
be locked by the exiting process. The CLI drops the win32 auto-install
gate and spawns the installer via PowerShell the same way it spawns
curl|bash on macOS/Linux, and sweeps any leftover renamed-aside binary
on the next startup.

Author: elkaix

.changeset/windows-native-auto-update.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Enable automatic updates for native installs on Windows: /update now installs the new version in the background instead of printing a manual command, and the installer safely replaces the running executable.

apps/pythinker-code/src/cli/update/preflight.ts

@@ -99,7 +99,7 @@ export function installCommandFor(
 
 export type AutomaticUpdateMode = 'background-install' | 'restart-install' | 'manual';
 
-export function canAutoInstall(source: InstallSource, platform: NodeJS.Platform): boolean {
+export function canAutoInstall(source: InstallSource, _platform: NodeJS.Platform): boolean {
   switch (source) {
     case 'npm-global':
     case 'pnpm-global':
@@ -111,7 +111,7 @@ export function canAutoInstall(source: InstallSource, platform: NodeJS.Platform)
       // TUI updates use the separate prepare-on-restart lifecycle instead.
       return false;
     case 'native':
-      return platform !== 'win32';
+      return true;
     case 'unsupported':
       return false;
   }
@@ -147,6 +147,12 @@ export function spawnForSource(
     case 'homebrew':
       return { cmd: 'brew', args: ['upgrade', 'pythinker-code'] };
     case 'native':
+      if (platform === 'win32') {
+        return {
+          cmd: 'powershell.exe',
+          args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', NATIVE_INSTALL_COMMAND_WIN],
+        };
+      }
       // `curl … | bash` reports only the trailing bash's exit status, so a
       // failed download (curl can't connect → empty stdin → bash exits 0)
       // would look like a successful update. `pipefail` makes the pipeline
@@ -176,7 +182,7 @@ export function renderManualUpdateMessage(
       sourceDesc = 'homebrew';
       break;
     case 'native':
-      sourceDesc = 'native (windows). Auto-update is not supported on this platform.';
+      sourceDesc = 'native install.';
       break;
     case 'unsupported':
       sourceDesc = 'unsupported package manager or layout.';

apps/pythinker-code/src/main.ts

@@ -41,7 +41,7 @@ import {
 import { dispatchUpdateHelperIfRequested } from './cli/update/update-helper';
 import { createPythinkerCodeHostIdentity, getVersion } from './cli/version';
 import { CLI_SHUTDOWN_TIMEOUT_MS, CLI_UI_MODE, PROCESS_NAME } from './constant/app';
-import { cleanupStaleNativeCacheForCurrent } from './native/native-assets';
+import { cleanupStaleNativeCacheForCurrent, cleanupStaleUpdateBackup } from './native/native-assets';
 import { installNativeModuleHook } from './native/module-hook';
 import { runNativeAssetSmokeIfRequested } from './native/smoke';
 
@@ -181,6 +181,8 @@ export function main(): void {
     } catch {
       // ignore: cache GC must never affect process startup
     }
+    // Sweep a leftover `pythinker.exe.old` from a prior Windows native update.
+    cleanupStaleUpdateBackup();
   });
 
   const version = getVersion();

apps/pythinker-code/src/native/native-assets.ts

@@ -378,3 +378,24 @@ export function cleanupStaleNativeCacheForCurrent(
     currentRoot,
   });
 }
+
+/**
+ * Windows native installs can't overwrite a running exe, so the updater
+ * renames the old one aside to `pythinker.exe.old` before writing the
+ * replacement. Best-effort cleanup at the next startup; the file may still
+ * be locked (AV scan, slow parent exit) — ignore and retry next launch.
+ */
+export function cleanupStaleUpdateBackup(
+  options: { readonly execPath?: string; readonly platform?: NodeJS.Platform; readonly isSea?: boolean } = {},
+): void {
+  const platform = options.platform ?? process.platform;
+  if (platform !== 'win32') return;
+  const isSea = options.isSea ?? getSeaAssetSource() !== null;
+  if (!isSea) return;
+  const execPath = options.execPath ?? process.execPath;
+  try {
+    rmSync(`${execPath}.old`, { force: true });
+  } catch {
+    // Locked or absent; the next startup retries.
+  }
+}

apps/pythinker-code/test/cli/update/preflight.test.ts

@@ -10,7 +10,7 @@ import {
   readUpdateInstallState,
   writeUpdateInstallState,
 } from '#/cli/update/install-state';
-import { runUpdatePreflight, spawnForSource, startManualUpdate } from '#/cli/update/preflight';
+import { canAutoInstall, runUpdatePreflight, spawnForSource, startManualUpdate } from '#/cli/update/preflight';
 import { promptForInstallChoice } from '#/cli/update/prompt';
 import type * as PromptModule from '#/cli/update/prompt';
 import { refreshUpdateCache } from '#/cli/update/refresh';
@@ -552,18 +552,30 @@ describe('runUpdatePreflight', () => {
     }
   });
 
-  it('native on win32: prints manual powershell command, does not spawn', async () => {
+  it('native on win32: starts a background powershell install, no manual prompt', async () => {
     mocks.readUpdateCache.mockResolvedValue(cacheWith('0.5.0'));
     mocks.refreshUpdateCache.mockResolvedValue(cacheWith('0.5.0'));
     mocks.detectInstallSource.mockResolvedValue('native');
+    mockSpawnExit(0);
     const originalPlatform = process.platform;
     Object.defineProperty(process, 'platform', { value: 'win32' });
     try {
       const { stdout, options } = captureOutput();
       await expect(runUpdatePreflight('0.4.0', options)).resolves.toBe('continue');
-      expect(stdout.join('')).toContain('irm https://code.pythinker.com/pythinker-code/install.ps1 | iex');
+      await flushBackgroundInstall();
+      expect(stdout.join('')).toBe('');
       expect(promptForInstallChoice).not.toHaveBeenCalled();
-      expect(mocks.spawn).not.toHaveBeenCalled();
+      expect(mocks.spawn).toHaveBeenCalledWith(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-ExecutionPolicy',
+          'Bypass',
+          '-Command',
+          'irm https://code.pythinker.com/pythinker-code/install.ps1 | iex',
+        ],
+        { detached: true, stdio: 'ignore' },
+      );
     } finally {
       Object.defineProperty(process, 'platform', { value: originalPlatform });
     }
@@ -1473,8 +1485,8 @@ describe('spawnForSource native', () => {
   // so a curl that never connects (exit 7, empty stdin → bash exits 0) is
   // masked and the update is wrongly reported as successful. `set -o pipefail`
   // makes the pipeline surface curl's failure. Shadowing `curl` with a shell
-  // function keeps this offline and deterministic; skipped on Windows (no bash,
-  // and native auto-install is unsupported there anyway).
+  // function keeps this offline and deterministic; skipped on Windows (no bash
+  // to run this script with).
   it.skipIf(process.platform === 'win32')(
     'surfaces a failed curl download as a non-zero exit',
     () => {
@@ -1485,6 +1497,36 @@ describe('spawnForSource native', () => {
       expect(result.status).toBeGreaterThan(0);
     },
   );
+
+  it('darwin/linux: unchanged bash -c pipeline', () => {
+    const { cmd, args } = spawnForSource('native', '0.5.0', 'darwin');
+    expect(cmd).toBe('bash');
+    expect(args[0]).toBe('-c');
+    expect(args[1]).toContain('curl -fsSL https://code.pythinker.com/pythinker-code/install.sh');
+  });
+
+  it('win32: powershell.exe with -ExecutionPolicy Bypass and the irm|iex install command', () => {
+    const { cmd, args } = spawnForSource('native', '0.5.0', 'win32');
+    expect(cmd).toBe('powershell.exe');
+    expect(args).toEqual([
+      '-NoProfile',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-Command',
+      'irm https://code.pythinker.com/pythinker-code/install.ps1 | iex',
+    ]);
+  });
+});
+
+describe('canAutoInstall native', () => {
+  it('is true on win32 (rename-aside replace no longer needs the platform gate)', () => {
+    expect(canAutoInstall('native', 'win32')).toBe(true);
+  });
+
+  it('is true on darwin/linux', () => {
+    expect(canAutoInstall('native', 'darwin')).toBe(true);
+    expect(canAutoInstall('native', 'linux')).toBe(true);
+  });
 });
 
 describe('startManualUpdate', () => {

apps/pythinker-code/test/native/native-assets.test.ts

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 import {
+  cleanupStaleUpdateBackup,
   getNativeAssetFilePath,
   getNativeCacheBase,
   getNativePackageRoot,
@@ -158,3 +159,56 @@ describe('native assets', () => {
     }
   });
 });
+
+describe('cleanupStaleUpdateBackup', () => {
+  it('removes a leftover .old exe on win32 SEA installs', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'pythinker-update-backup-'));
+    const execPath = join(dir, 'pythinker.exe');
+    const stalePath = `${execPath}.old`;
+    writeFileSync(stalePath, 'stale');
+    try {
+      cleanupStaleUpdateBackup({ execPath, platform: 'win32', isSea: true });
+      expect(existsSync(stalePath)).toBe(false);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('is a no-op when there is nothing to clean up (missing file)', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'pythinker-update-backup-'));
+    const execPath = join(dir, 'pythinker.exe');
+    try {
+      expect(() => {
+        cleanupStaleUpdateBackup({ execPath, platform: 'win32', isSea: true });
+      }).not.toThrow();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('skips non-win32 platforms', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'pythinker-update-backup-'));
+    const execPath = join(dir, 'pythinker');
+    const stalePath = `${execPath}.old`;
+    writeFileSync(stalePath, 'stale');
+    try {
+      cleanupStaleUpdateBackup({ execPath, platform: 'darwin', isSea: true });
+      expect(existsSync(stalePath)).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('skips non-SEA (npm/dev) processes', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'pythinker-update-backup-'));
+    const execPath = join(dir, 'pythinker.exe');
+    const stalePath = `${execPath}.old`;
+    writeFileSync(stalePath, 'stale');
+    try {
+      cleanupStaleUpdateBackup({ execPath, platform: 'win32', isSea: false });
+      expect(existsSync(stalePath)).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

apps/pythinker-web/public/install.ps1

@@ -505,17 +505,48 @@ try {
   }
   Phase-Ok "Verifying"
 
-  # The release zip contains a single pythinker.exe at its root.
-  $extractDir = Join-Path $tempDir "extracted"
+  $installDir = Join-Path $env:LOCALAPPDATA "Programs\Pythinker"
+  New-Item -ItemType Directory -Path $installDir -Force | Out-Null
+
+  # The release zip contains a single pythinker.exe at its root. Extract
+  # into $installDir (not $env:TEMP) so the final Move-Item below is always
+  # a same-volume rename, never a cross-volume copy.
+  $extractDir = Join-Path $installDir ("update-" + [System.Guid]::NewGuid().ToString('N'))
   Expand-Archive -LiteralPath $installerPath -DestinationPath $extractDir -Force
   $binary = Join-Path $extractDir "pythinker.exe"
   if (-not (Test-Path $binary)) {
     Fail "archive did not contain pythinker.exe"
   }
 
-  $installDir = Join-Path $env:LOCALAPPDATA "Programs\Pythinker"
-  New-Item -ItemType Directory -Path $installDir -Force | Out-Null
-  Copy-Item -LiteralPath $binary -Destination (Join-Path $installDir "pythinker.exe") -Force
+  # A running pythinker.exe can be renamed but not overwritten or deleted on
+  # Windows. Rename it aside, move the new binary into place, then retry
+  # deleting the stale copy for a few seconds in case it's still locked by
+  # the running parent process or an AV scan.
+  $target = Join-Path $installDir "pythinker.exe"
+  $stale = "$target.old"
+  # Opportunistic cleanup of a previous update's leftover (may be locked; ignore).
+  if (Test-Path $stale) { Remove-Item -LiteralPath $stale -Force -ErrorAction SilentlyContinue }
+  if (Test-Path $target) {
+    try {
+      Rename-Item -LiteralPath $target -NewName "pythinker.exe.old" -Force -ErrorAction Stop
+    } catch {
+      Fail "could not rename existing pythinker.exe aside, a concurrent update may be in progress: $($_.Exception.Message)"
+    }
+  }
+  try {
+    Move-Item -LiteralPath $binary -Destination $target -Force -ErrorAction Stop
+  } catch {
+    # Roll the old exe back so the user is never left with no binary at all.
+    if ((Test-Path $stale) -and -not (Test-Path $target)) {
+      Rename-Item -LiteralPath $stale -NewName "pythinker.exe" -Force -ErrorAction SilentlyContinue
+    }
+    Fail "could not install the new pythinker.exe: $($_.Exception.Message)"
+  }
+  Remove-Item -Recurse -Force $extractDir -ErrorAction SilentlyContinue
+  for ($i = 0; $i -lt 5 -and (Test-Path $stale); $i++) {
+    Start-Sleep -Seconds 2
+    Remove-Item -LiteralPath $stale -Force -ErrorAction SilentlyContinue
+  }
   Phase-Ok "Installing"
 
   # Persist the install dir on the user PATH, and make it available in
@@ -533,4 +564,7 @@ try {
 } finally {
   Write-Host -NoNewline $SHOW
   Remove-Item -Recurse -Force $tempDir -ErrorAction SilentlyContinue
+  if ($extractDir) {
+    Remove-Item -Recurse -Force $extractDir -ErrorAction SilentlyContinue
+  }
 }