feat: add refresh_path_from_registry() to fix Windows PATH propagation

After winget installs Node.js, the registry PATH is updated but the
running Python process still has the old os.environ['PATH']. This
causes npm commands to fail because the subprocess cannot find npm.

This commit:
- Adds refresh_path_from_registry() to read PATH from Windows registry
- Splits install_dependencies() into platform-specific and common phases
- Calls PATH refresh between phases so npm can find Node.js

The function reads both system (HKLM) and user (HKCU) PATH values,
handles REG_EXPAND_SZ with environment variable expansion, and
combines them with system PATH first for security.

Author: alex-feel

scripts/setup_environment.py

@@ -697,6 +697,109 @@ def cleanup_temp_paths_from_registry() -> tuple[int, list[str]]:
         return 0, []
 
 
+def refresh_path_from_registry() -> bool:
+    """Refresh os.environ['PATH'] from Windows registry.
+
+    Reads both system and user PATH values from the Windows registry and
+    updates os.environ['PATH'] with the combined value. This addresses
+    the Windows PATH propagation bug where installations (e.g., winget)
+    update the registry but running processes don't see the changes.
+
+    Registry sources:
+        - System PATH: HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment
+        - User PATH: HKEY_CURRENT_USER\\Environment
+
+    Returns:
+        True if PATH was successfully refreshed, False otherwise.
+
+    Note:
+        - Only works on Windows (returns True on other platforms as no-op)
+        - Handles REG_EXPAND_SZ values with environment variable expansion
+        - Combines system PATH + user PATH (system first for security)
+        - Logs info message when PATH is refreshed
+    """
+    if sys.platform == 'win32':
+        try:
+
+            def expand_env_vars(value: str) -> str:
+                """Expand environment variables like %USERPROFILE% in registry values."""
+                # Use os.path.expandvars which handles %VAR% on Windows
+                return os.path.expandvars(value)
+
+            system_path = ''
+            user_path = ''
+
+            # Read system PATH from HKEY_LOCAL_MACHINE
+            try:
+                with winreg.OpenKey(
+                    winreg.HKEY_LOCAL_MACHINE,
+                    r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment',
+                    0,
+                    winreg.KEY_READ | winreg.KEY_WOW64_64KEY,
+                ) as key:
+                    raw_value, reg_type = winreg.QueryValueEx(key, 'Path')
+                    if raw_value:
+                        # Expand environment variables if REG_EXPAND_SZ
+                        system_path = expand_env_vars(raw_value) if reg_type == winreg.REG_EXPAND_SZ else raw_value
+            except FileNotFoundError:
+                # System PATH key doesn't exist (very unusual)
+                pass
+            except PermissionError:
+                # May not have permission to read system PATH
+                warning('Permission denied reading system PATH from registry')
+            except OSError as e:
+                warning(f'Failed to read system PATH from registry: {e}')
+
+            # Read user PATH from HKEY_CURRENT_USER
+            try:
+                with winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER,
+                    r'Environment',
+                    0,
+                    winreg.KEY_READ,
+                ) as key:
+                    raw_value, reg_type = winreg.QueryValueEx(key, 'Path')
+                    if raw_value:
+                        # Expand environment variables if REG_EXPAND_SZ
+                        user_path = expand_env_vars(raw_value) if reg_type == winreg.REG_EXPAND_SZ else raw_value
+            except FileNotFoundError:
+                # User PATH doesn't exist (possible on fresh systems)
+                pass
+            except PermissionError:
+                warning('Permission denied reading user PATH from registry')
+            except OSError as e:
+                warning(f'Failed to read user PATH from registry: {e}')
+
+            # Combine paths: system PATH first, then user PATH
+            # This matches Windows behavior where system PATH takes precedence
+            if system_path and user_path:
+                new_path = f'{system_path};{user_path}'
+            elif system_path:
+                new_path = system_path
+            elif user_path:
+                new_path = user_path
+            else:
+                # No PATH found in registry, keep current
+                warning('No PATH found in registry, keeping current os.environ PATH')
+                return False
+
+            # Update os.environ with the refreshed PATH
+            old_path = os.environ.get('PATH', '')
+            if new_path != old_path:
+                os.environ['PATH'] = new_path
+                info('Refreshed PATH from Windows registry')
+                return True
+            # PATH unchanged, no need to log
+            return True
+
+        except Exception as e:
+            warning(f'Failed to refresh PATH from registry: {e}')
+            return False
+    else:
+        # Non-Windows platforms: no-op, return True
+        return True
+
+
 def check_file_with_head(url: str, auth_headers: dict[str, str] | None = None) -> bool:
     """Check if file exists using HEAD request.
 
@@ -2107,61 +2210,69 @@ def install_dependencies(dependencies: dict[str, list[str]] | None) -> bool:
     # Collect dependencies: platform-specific first, then common
     # This ensures platform runtimes (e.g., Node.js) are installed before
     # common tools that depend on them (e.g., npm packages)
-    deps_to_install: list[str] = []
+    platform_deps_list: list[str] = []
+    common_deps_list: list[str] = []
 
-    # Add platform-specific dependencies first (e.g., Node.js runtime)
+    # Collect platform-specific dependencies (e.g., Node.js runtime)
     if current_platform_key:
         platform_deps = dependencies.get(current_platform_key, [])
         if platform_deps:
             info(f'Found {len(platform_deps)} {current_platform_key}-specific dependencies')
-            deps_to_install.extend(platform_deps)
+            platform_deps_list = list(platform_deps)
 
-    # Add common dependencies second (e.g., npm packages that need Node.js)
+    # Collect common dependencies (e.g., npm packages that need Node.js)
     common_deps = dependencies.get('common', [])
     if common_deps:
         info(f'Found {len(common_deps)} common dependencies')
-        deps_to_install.extend(common_deps)
+        common_deps_list = list(common_deps)
 
-    if not deps_to_install:
+    if not platform_deps_list and not common_deps_list:
         info('No dependencies to install for this platform')
         return True
 
-    # Execute all collected dependencies
-    for dep in deps_to_install:
+    # Helper function to execute a single dependency
+    def execute_dependency(dep: str) -> bool:
+        """Execute a single dependency command. Returns True on success."""
         info(f'Running: {dep}')
-
-        # Parse the command
         parts = dep.split()
 
-        # Handle platform-specific commands
         if system == 'Windows':
             if parts[0] in ['winget', 'npm', 'pip', 'pipx']:
                 result = run_command(parts, capture_output=False)
-            elif parts[0] == 'uv' and parts[1] == 'tool' and parts[2] == 'install':
-                # For uv tool install, add --force to update if already installed
+            elif parts[0] == 'uv' and len(parts) >= 3 and parts[1] == 'tool' and parts[2] == 'install':
                 parts_with_force = parts[:3] + ['--force'] + parts[3:]
                 result = run_command(parts_with_force, capture_output=False)
             else:
-                # Try PowerShell for other commands
                 result = run_command(['powershell', '-Command', dep], capture_output=False)
         else:
-            # Unix-like systems
             if parts[0] == 'uv' and len(parts) >= 3 and parts[1] == 'tool' and parts[2] == 'install':
-                # For uv tool install, add --force to update if already installed
                 dep_with_force = dep.replace('uv tool install', 'uv tool install --force')
                 result = run_command(['bash', '-c', dep_with_force], capture_output=False)
             else:
-                # Execute command as-is (expand tilde paths before execution)
                 expanded_dep = expand_tildes_in_command(dep)
                 result = run_command(['bash', '-c', expanded_dep], capture_output=False)
 
         if result.returncode != 0:
             error(f'Failed to install dependency: {dep}')
-            # Check if it failed due to admin rights on Windows
             if system == 'Windows' and not is_admin() and 'winget' in dep and '--scope machine' in dep:
                 warning('This may have failed due to lack of admin rights')
                 info('Try: 1) Run as administrator, or 2) Use --scope user instead')
             warning('Continuing with other dependencies...')
+            return False
+        return True
+
+    # Phase 1: Execute platform-specific dependencies
+    for dep in platform_deps_list:
+        execute_dependency(dep)
+
+    # Phase 2: Refresh PATH from registry on Windows
+    # This picks up any PATH changes from platform-specific installations (e.g., Node.js)
+    if system == 'Windows' and platform_deps_list:
+        refresh_path_from_registry()
+
+    # Phase 3: Execute common dependencies
+    for dep in common_deps_list:
+        execute_dependency(dep)
 
     return True
 

tests/test_setup_environment_additional.py

@@ -2204,3 +2204,144 @@ def test_linux_continue_mode_message(self, _mock_system):
 
             # Should have different echo message for continue mode
             assert 'Resuming Claude Code session' in content or 'Continue mode' in content
+
+
+class TestRefreshPathFromRegistry:
+    """Test refresh_path_from_registry() function."""
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_success(self):
+        """Test successful PATH refresh from registry."""
+        # This test runs on actual Windows - verifies function doesn't crash
+        result = setup_environment.refresh_path_from_registry()
+        assert result is True
+        assert os.environ.get('PATH')  # PATH should exist after refresh
+
+    def test_refresh_path_from_registry_non_windows(self):
+        """Test function is no-op on non-Windows platforms."""
+        with patch('sys.platform', 'linux'):
+            result = setup_environment.refresh_path_from_registry()
+            assert result is True  # Should return True (no-op success)
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_system_path_only(self):
+        """Test when only system PATH exists."""
+        import winreg
+
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        # First call for system PATH succeeds, second for user PATH raises FileNotFoundError
+        call_count = [0]
+
+        def open_key_side_effect(*_args, **_kwargs):  # noqa: ARG001
+            call_count[0] += 1
+            if call_count[0] == 1:  # System PATH
+                return mock_key
+            # User PATH
+            raise FileNotFoundError
+
+        with (
+            patch('setup_environment.winreg.OpenKey', side_effect=open_key_side_effect),
+            patch('setup_environment.winreg.QueryValueEx') as mock_query,
+        ):
+            mock_query.return_value = (r'C:\Windows\System32', winreg.REG_SZ)
+
+            result = setup_environment.refresh_path_from_registry()
+            assert result is True
+            assert r'C:\Windows\System32' in os.environ.get('PATH', '')
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_user_path_only(self):
+        """Test when only user PATH exists."""
+        import winreg
+
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        # First call for system PATH raises, second for user PATH succeeds
+        call_count = [0]
+
+        def open_key_side_effect(*_args, **_kwargs):  # noqa: ARG001
+            call_count[0] += 1
+            if call_count[0] == 1:  # System PATH
+                raise FileNotFoundError
+            # User PATH
+            return mock_key
+
+        with (
+            patch('setup_environment.winreg.OpenKey', side_effect=open_key_side_effect),
+            patch('setup_environment.winreg.QueryValueEx') as mock_query,
+        ):
+            mock_query.return_value = (r'C:\Users\Test\.local\bin', winreg.REG_SZ)
+
+            result = setup_environment.refresh_path_from_registry()
+            assert result is True
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_combined_paths(self):
+        """Test combining system and user PATH."""
+        import winreg
+
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with patch('setup_environment.winreg.OpenKey', return_value=mock_key):
+            # Return different values for system and user PATH
+            call_count = [0]
+
+            def query_side_effect(*_args, **_kwargs):  # noqa: ARG001
+                call_count[0] += 1
+                if call_count[0] == 1:  # System PATH
+                    return (r'C:\Windows\System32', winreg.REG_SZ)
+                # User PATH
+                return (r'C:\Users\Test\.local\bin', winreg.REG_SZ)
+
+            with patch('setup_environment.winreg.QueryValueEx', side_effect=query_side_effect):
+                result = setup_environment.refresh_path_from_registry()
+                assert result is True
+                path = os.environ.get('PATH', '')
+                # System PATH should come first
+                assert path.startswith(r'C:\Windows\System32')
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_expands_env_vars(self):
+        """Test that REG_EXPAND_SZ values are expanded."""
+        import winreg
+
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch('setup_environment.winreg.OpenKey', return_value=mock_key),
+            patch('setup_environment.winreg.QueryValueEx') as mock_query,
+            patch.dict(os.environ, {'USERPROFILE': r'C:\Users\TestUser'}),
+        ):
+            # Return a path with %USERPROFILE%
+            mock_query.return_value = (r'%USERPROFILE%\.local\bin', winreg.REG_EXPAND_SZ)
+
+            result = setup_environment.refresh_path_from_registry()
+            assert result is True
+            path = os.environ.get('PATH', '')
+            # %USERPROFILE% should be expanded
+            assert r'C:\Users\TestUser' in path
+            assert '%USERPROFILE%' not in path
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_permission_error(self):
+        """Test handling of permission errors."""
+        with patch('setup_environment.winreg.OpenKey', side_effect=PermissionError('Access denied')):
+            result = setup_environment.refresh_path_from_registry()
+            # Should return False but not crash
+            assert result is False
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows-specific test')
+    def test_refresh_path_from_registry_no_path_found(self):
+        """Test when no PATH found in registry."""
+        with patch('setup_environment.winreg.OpenKey', side_effect=FileNotFoundError()):
+            result = setup_environment.refresh_path_from_registry()
+            assert result is False  # Should return False when no PATH found