From 13d341ef292170c3bbd802a702360087d0ca03cd Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 20 Oct 2025 14:30:39 -0700
Subject: [PATCH 001/106] Initial commit of Windows CI for Java

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/json_matrices/build-matrix.json       | 10 ++++
 .../install-rust-and-protoc/action.yml        |  1 +
 .../install-shared-dependencies/action.yml    | 34 ++++++++++++-
 .github/workflows/java.yml                    | 50 +++++++++++++++++--
 4 files changed, 91 insertions(+), 4 deletions(-)

diff --git a/.github/json_matrices/build-matrix.json b/.github/json_matrices/build-matrix.json
index 098a676f16..da073a96c9 100644
--- a/.github/json_matrices/build-matrix.json
+++ b/.github/json_matrices/build-matrix.json
@@ -81,5 +81,15 @@
         "IMAGE": "amazonlinux:latest",
         "PACKAGE_MANAGERS": [],
         "languages": ["python", "node", "java", "go"]
+    },
+    {
+        "OS": "windows",
+        "NAMED_OS": "windows",
+        "RUNNER": "windows-latest",
+        "ARCH": "x64",
+        "TARGET": "x86_64-pc-windows-msvc",
+        "PACKAGE_MANAGERS": ["maven"],
+        "languages": ["java"],
+        "run": "always"
     }
 ]
diff --git a/.github/workflows/install-rust-and-protoc/action.yml b/.github/workflows/install-rust-and-protoc/action.yml
index 9dee133a42..a7237effbd 100644
--- a/.github/workflows/install-rust-and-protoc/action.yml
+++ b/.github/workflows/install-rust-and-protoc/action.yml
@@ -11,6 +11,7 @@ inputs:
             - aarch64-unknown-linux-gnu
             - x86_64-apple-darwin
             - aarch64-apple-darwin
+            - x86_64-pc-windows-msvc
     github-token:
         description: "GitHub token"
         type: string
diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 5ae71e53bb..eba4fef62b 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -9,6 +9,7 @@ inputs:
             - amazon-linux
             - macos
             - ubuntu
+            - windows
     target:
         description: "Specified target for rust toolchain, ex. x86_64-apple-darwin"
         type: string
@@ -21,6 +22,7 @@ inputs:
             - aarch64-apple-darwin
             - aarch64-unknown-linux-musl
             - x86_64-unknown-linux-musl
+            - x86_64-pc-windows-msvc
     engine-version:
         description: "Engine version to install"
         required: false
@@ -62,6 +64,36 @@ runs:
           run: |
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
+        - name: Install software dependencies for Windows
+          shell: pwsh
+          if: "${{ inputs.os == 'windows' }}"
+          run: |
+              # Verify build tools are available (windows-latest should have these)
+              Write-Host "Checking build tools..."
+              rustc --version
+              cargo --version
+              cl.exe 2>&1 | Select-String "Microsoft"
+
+        - name: Setup WSL and install Valkey (Windows)
+          shell: pwsh
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          run: |
+              # Install WSL2 with Ubuntu
+              wsl --install --no-launch Ubuntu-22.04
+              wsl --set-default-version 2
+              
+              # Wait for WSL to be ready
+              Start-Sleep -Seconds 10
+              
+              # Install dependencies and Valkey in WSL
+              wsl -d Ubuntu-22.04 -- sudo apt update
+              wsl -d Ubuntu-22.04 -- sudo apt install -y build-essential git pkg-config libssl-dev
+              wsl -d Ubuntu-22.04 -- git clone https://github.com/valkey-io/valkey.git
+              wsl -d Ubuntu-22.04 -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
+              
+              # Start Valkey server in WSL background
+              wsl -d Ubuntu-22.04 -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
           uses: ./.github/workflows/install-rust-and-protoc
@@ -70,7 +102,7 @@ runs:
               github-token: ${{ inputs.github-token }}
 
         - name: Install engine
-          if: "${{ inputs.engine-version }}"
+          if: "${{ inputs.engine-version && inputs.os != 'windows' }}"
           uses: ./.github/workflows/install-engine
           with:
               engine-version: ${{ inputs.engine-version }}
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index a9cc7706b3..35c3a3b2be 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -155,11 +155,36 @@ jobs:
 
             - name: Build java client
               working-directory: java
-              run: ./gradlew --build-cache --continue build -x javadoc
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache --continue build -x javadoc
+                  else
+                      ./gradlew --build-cache --continue build -x javadoc
+                  fi
+
+            - name: Setup WSL networking for tests (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: pwsh
+              run: |
+                  # Get WSL IP address and set environment variable for tests
+                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
+                  
+                  # Verify Valkey is running in WSL
+                  wsl -d Ubuntu-22.04 -- redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
-              run: ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  else
+                      ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  fi
 
             - uses: ./.github/workflows/test-benchmark
               if: ${{ matrix.engine.version == '8.0' && matrix.host.RUNNER == 'ubuntu-latest' && matrix.java == '17' }}
@@ -239,9 +264,28 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
+            - name: Setup WSL networking for PubSub tests (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: pwsh
+              run: |
+                  # Get WSL IP address and set environment variable for tests
+                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
+                  
+                  # Verify Valkey is running in WSL
+                  wsl -d Ubuntu-22.04 -- redis-cli ping
+
             - name: Test pubsub
               working-directory: java
-              run: ./gradlew --build-cache :integTest:pubsubTest
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache :integTest:pubsubTest
+                  else
+                      ./gradlew --build-cache :integTest:pubsubTest
+                  fi
 
             - name: Upload test & spotbugs reports
               if: always()

From 21b72786c318e7991bf45688d85cddf5eed04426 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 20 Oct 2025 14:36:33 -0700
Subject: [PATCH 002/106] Verify build tools the same way as in C#

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index eba4fef62b..d98fca4df9 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -68,11 +68,9 @@ runs:
           shell: pwsh
           if: "${{ inputs.os == 'windows' }}"
           run: |
-              # Verify build tools are available (windows-latest should have these)
-              Write-Host "Checking build tools..."
+              # Verify Rust toolchain is available
               rustc --version
               cargo --version
-              cl.exe 2>&1 | Select-String "Microsoft"
 
         - name: Setup WSL and install Valkey (Windows)
           shell: pwsh

From b3f04e6fdd6ebe317524a342181374a042f19e15 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 20 Oct 2025 15:40:17 -0700
Subject: [PATCH 003/106] Make Windows requirements for Java only affect Java
 runs

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 24 ++++++++++++-------
 .github/workflows/java.yml                    | 19 +++++++++++----
 2 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index d98fca4df9..ab5d542655 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -27,6 +27,10 @@ inputs:
         description: "Engine version to install"
         required: false
         type: string
+    language:
+        description: "The language being built (optional, for language-specific setup)"
+        required: false
+        type: string
     github-token:
         description: "GITHUB_TOKEN, GitHub App installation access token"
         required: true
@@ -72,25 +76,29 @@ runs:
               rustc --version
               cargo --version
 
-        - name: Setup WSL and install Valkey (Windows)
+        - name: Setup WSL and install Valkey (Windows + Java)
           shell: pwsh
-          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
           run: |
               # Install WSL2 with Ubuntu
               wsl --install --no-launch Ubuntu-22.04
               wsl --set-default-version 2
               
               # Wait for WSL to be ready
-              Start-Sleep -Seconds 10
+              Start-Sleep -Seconds 15
+              
+              # Get the actual distribution name
+              $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+              Write-Host "Using WSL distribution: $distroName"
               
               # Install dependencies and Valkey in WSL
-              wsl -d Ubuntu-22.04 -- sudo apt update
-              wsl -d Ubuntu-22.04 -- sudo apt install -y build-essential git pkg-config libssl-dev
-              wsl -d Ubuntu-22.04 -- git clone https://github.com/valkey-io/valkey.git
-              wsl -d Ubuntu-22.04 -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
+              wsl -d $distroName -- sudo apt update
+              wsl -d $distroName -- sudo apt install -y build-essential git pkg-config libssl-dev
+              wsl -d $distroName -- git clone https://github.com/valkey-io/valkey.git
+              wsl -d $distroName -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
               
               # Start Valkey server in WSL background
-              wsl -d Ubuntu-22.04 -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+              wsl -d $distroName -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 35c3a3b2be..1c5bcad8a7 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -126,6 +126,7 @@ jobs:
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
                   engine-version: ${{ matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
               uses: arduino/setup-protoc@v3
@@ -167,14 +168,18 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
+                  # Get the actual distribution name
+                  $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+                  Write-Host "Using WSL distribution: $distroName"
+                  
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -d $distroName -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -d Ubuntu-22.04 -- redis-cli ping
+                  wsl -d $distroName -- redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -237,6 +242,7 @@ jobs:
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
                   engine-version: ${{ matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
               uses: arduino/setup-protoc@v3
@@ -268,14 +274,18 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
+                  # Get the actual distribution name
+                  $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+                  Write-Host "Using WSL distribution: $distroName"
+                  
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -d $distroName -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -d Ubuntu-22.04 -- redis-cli ping
+                  wsl -d $distroName -- redis-cli ping
 
             - name: Test pubsub
               working-directory: java
@@ -363,6 +373,7 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
+                  language: java
                   engine-version: ${{ matrix.engine.version }}
 
             - name: Install protoc (protobuf)

From 7be5c025f7cb1798f510475dcbc0bfd136d4bd57 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 20 Oct 2025 15:49:29 -0700
Subject: [PATCH 004/106] Syntax errors in Go workflows

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/go.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 452e3b55f0..536254a25b 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -152,6 +152,7 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |
@@ -384,6 +385,7 @@ jobs:
 
             - name: Build and test
               working-directory: ./go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |
@@ -457,6 +459,7 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |

From 499f2e5b94202bab2e01ef7a6c3e4dcae28f26e4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 20 Oct 2025 17:03:13 -0700
Subject: [PATCH 005/106] Correctly disable windows when build is set to always
 but Windows isn't supported

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/create-test-matrices/action.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/create-test-matrices/action.yml b/.github/workflows/create-test-matrices/action.yml
index b08dea10a4..35d14a3075 100644
--- a/.github/workflows/create-test-matrices/action.yml
+++ b/.github/workflows/create-test-matrices/action.yml
@@ -78,8 +78,8 @@ runs:
               echo 'Select runners (VMs) to run tests on'
 
               if [[ "$EVENT_NAME" == "pull_request" || "$EVENT_NAME" == "push" || "$RUN_FULL_MATRIX" == "false" ]]; then
-                echo 'Getting "always run" runners'
-                BASE_MATRIX=$(jq -c '[.[] | select(.run == "always")]' < .github/json_matrices/build-matrix.json)
+                echo 'Getting "always run" runners for this language'
+                BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.run == "always" and .languages? and any(.languages[] == $lang; .) and '"$CONDITION"')]' < .github/json_matrices/build-matrix.json)
               else
                 echo 'Getting full matrix for language excluding macOS'
                 BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.languages? and any(.languages[] == $lang; .) and '"$CONDITION"' and .TARGET != "aarch64-apple-darwin")]' < .github/json_matrices/build-matrix.json)

From d5fb7aa72aac3560bcf61a6a46689935ddcc26f8 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 06:33:20 -0700
Subject: [PATCH 006/106] Debugging windows CI failures

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 31 +++++++++-
 .github/workflows/java.yml                    | 62 +++++++++++++++++--
 2 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index ab5d542655..ce4df794f2 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -87,8 +87,35 @@ runs:
               # Wait for WSL to be ready
               Start-Sleep -Seconds 15
               
-              # Get the actual distribution name
-              $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+              # Get the actual distribution name - try multiple approaches
+              $distroName = $null
+              try {
+                  $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
+                  if ($distros) {
+                      $distroName = $distros[0].Trim()
+                  }
+              } catch {
+                  Write-Host "Failed to get distro list, trying default names..."
+              }
+              
+              # Fallback to common names if detection fails
+              if (-not $distroName) {
+                  $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
+                  foreach ($name in $possibleNames) {
+                      try {
+                          wsl -d $name -- echo "test" 2>$null
+                          $distroName = $name
+                          break
+                      } catch {
+                          continue
+                      }
+                  }
+              }
+              
+              if (-not $distroName) {
+                  throw "Could not find Ubuntu WSL distribution"
+              }
+              
               Write-Host "Using WSL distribution: $distroName"
               
               # Install dependencies and Valkey in WSL
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 1c5bcad8a7..168e45d038 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -168,8 +168,35 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Get the actual distribution name
-                  $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+                  # Get the actual distribution name - try multiple approaches
+                  $distroName = $null
+                  try {
+                      $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
+                      if ($distros) {
+                          $distroName = $distros[0].Trim()
+                      }
+                  } catch {
+                      Write-Host "Failed to get distro list, trying default names..."
+                  }
+                  
+                  # Fallback to common names if detection fails
+                  if (-not $distroName) {
+                      $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
+                      foreach ($name in $possibleNames) {
+                          try {
+                              wsl -d $name -- echo "test" 2>$null
+                              $distroName = $name
+                              break
+                          } catch {
+                              continue
+                          }
+                      }
+                  }
+                  
+                  if (-not $distroName) {
+                      throw "Could not find Ubuntu WSL distribution"
+                  }
+                  
                   Write-Host "Using WSL distribution: $distroName"
                   
                   # Get WSL IP address and set environment variable for tests
@@ -274,8 +301,35 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Get the actual distribution name
-                  $distroName = (wsl -l -q | Where-Object { $_ -match "Ubuntu" } | Select-Object -First 1).Trim()
+                  # Get the actual distribution name - try multiple approaches
+                  $distroName = $null
+                  try {
+                      $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
+                      if ($distros) {
+                          $distroName = $distros[0].Trim()
+                      }
+                  } catch {
+                      Write-Host "Failed to get distro list, trying default names..."
+                  }
+                  
+                  # Fallback to common names if detection fails
+                  if (-not $distroName) {
+                      $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
+                      foreach ($name in $possibleNames) {
+                          try {
+                              wsl -d $name -- echo "test" 2>$null
+                              $distroName = $name
+                              break
+                          } catch {
+                              continue
+                          }
+                      }
+                  }
+                  
+                  if (-not $distroName) {
+                      throw "Could not find Ubuntu WSL distribution"
+                  }
+                  
                   Write-Host "Using WSL distribution: $distroName"
                   
                   # Get WSL IP address and set environment variable for tests

From 360e376ebb4c3364a7a969c159019278ed573358 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 09:38:00 -0700
Subject: [PATCH 007/106] Fixing distro name

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 39 ++++--------
 .github/workflows/java.yml                    | 62 ++-----------------
 2 files changed, 16 insertions(+), 85 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index ce4df794f2..451885184c 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -87,37 +87,22 @@ runs:
               # Wait for WSL to be ready
               Start-Sleep -Seconds 15
               
-              # Get the actual distribution name - try multiple approaches
-              $distroName = $null
+              # The distribution is installed as "Ubuntu 22.04 LTS" based on the output
+              $distroName = "Ubuntu 22.04 LTS"
+              Write-Host "Using WSL distribution: $distroName"
+              
+              # Verify the distribution exists
               try {
-                  $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
-                  if ($distros) {
-                      $distroName = $distros[0].Trim()
-                  }
+                  wsl -d $distroName -- echo "WSL distribution verified"
               } catch {
-                  Write-Host "Failed to get distro list, trying default names..."
-              }
-              
-              # Fallback to common names if detection fails
-              if (-not $distroName) {
-                  $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
-                  foreach ($name in $possibleNames) {
-                      try {
-                          wsl -d $name -- echo "test" 2>$null
-                          $distroName = $name
-                          break
-                      } catch {
-                          continue
-                      }
-                  }
+                  # If that fails, try to find it dynamically
+                  Write-Host "Trying to find Ubuntu distribution..."
+                  $allDistros = wsl -l -v 2>$null
+                  Write-Host "Available distributions:"
+                  Write-Host $allDistros
+                  throw "Could not connect to Ubuntu WSL distribution"
               }
               
-              if (-not $distroName) {
-                  throw "Could not find Ubuntu WSL distribution"
-              }
-              
-              Write-Host "Using WSL distribution: $distroName"
-              
               # Install dependencies and Valkey in WSL
               wsl -d $distroName -- sudo apt update
               wsl -d $distroName -- sudo apt install -y build-essential git pkg-config libssl-dev
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 168e45d038..2ce0a06d8d 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -168,35 +168,8 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Get the actual distribution name - try multiple approaches
-                  $distroName = $null
-                  try {
-                      $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
-                      if ($distros) {
-                          $distroName = $distros[0].Trim()
-                      }
-                  } catch {
-                      Write-Host "Failed to get distro list, trying default names..."
-                  }
-                  
-                  # Fallback to common names if detection fails
-                  if (-not $distroName) {
-                      $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
-                      foreach ($name in $possibleNames) {
-                          try {
-                              wsl -d $name -- echo "test" 2>$null
-                              $distroName = $name
-                              break
-                          } catch {
-                              continue
-                          }
-                      }
-                  }
-                  
-                  if (-not $distroName) {
-                      throw "Could not find Ubuntu WSL distribution"
-                  }
-                  
+                  # Use the known distribution name from installation
+                  $distroName = "Ubuntu 22.04 LTS"
                   Write-Host "Using WSL distribution: $distroName"
                   
                   # Get WSL IP address and set environment variable for tests
@@ -301,35 +274,8 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Get the actual distribution name - try multiple approaches
-                  $distroName = $null
-                  try {
-                      $distros = wsl -l -q 2>$null | Where-Object { $_ -and $_.Trim() -match "Ubuntu" }
-                      if ($distros) {
-                          $distroName = $distros[0].Trim()
-                      }
-                  } catch {
-                      Write-Host "Failed to get distro list, trying default names..."
-                  }
-                  
-                  # Fallback to common names if detection fails
-                  if (-not $distroName) {
-                      $possibleNames = @("Ubuntu-22.04", "Ubuntu 22.04 LTS", "Ubuntu")
-                      foreach ($name in $possibleNames) {
-                          try {
-                              wsl -d $name -- echo "test" 2>$null
-                              $distroName = $name
-                              break
-                          } catch {
-                              continue
-                          }
-                      }
-                  }
-                  
-                  if (-not $distroName) {
-                      throw "Could not find Ubuntu WSL distribution"
-                  }
-                  
+                  # Use the known distribution name from installation
+                  $distroName = "Ubuntu 22.04 LTS"
                   Write-Host "Using WSL distribution: $distroName"
                   
                   # Get WSL IP address and set environment variable for tests

From fbc416bc258399ef21bce327ad47954f147635f0 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 10:06:14 -0700
Subject: [PATCH 008/106] Attempt to fix WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 33 +++++++------------
 .github/workflows/java.yml                    | 18 +++++-----
 2 files changed, 20 insertions(+), 31 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 451885184c..9372d96545 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -85,32 +85,23 @@ runs:
               wsl --set-default-version 2
               
               # Wait for WSL to be ready
-              Start-Sleep -Seconds 15
+              Start-Sleep -Seconds 20
               
-              # The distribution is installed as "Ubuntu 22.04 LTS" based on the output
-              $distroName = "Ubuntu 22.04 LTS"
-              Write-Host "Using WSL distribution: $distroName"
+              # Set Ubuntu as default distribution to avoid name issues
+              wsl --set-default "Ubuntu 22.04 LTS"
               
-              # Verify the distribution exists
-              try {
-                  wsl -d $distroName -- echo "WSL distribution verified"
-              } catch {
-                  # If that fails, try to find it dynamically
-                  Write-Host "Trying to find Ubuntu distribution..."
-                  $allDistros = wsl -l -v 2>$null
-                  Write-Host "Available distributions:"
-                  Write-Host $allDistros
-                  throw "Could not connect to Ubuntu WSL distribution"
-              }
+              # Verify WSL is working by using default (no -d flag needed)
+              Write-Host "Testing WSL connection..."
+              wsl -- echo "WSL connection successful"
               
-              # Install dependencies and Valkey in WSL
-              wsl -d $distroName -- sudo apt update
-              wsl -d $distroName -- sudo apt install -y build-essential git pkg-config libssl-dev
-              wsl -d $distroName -- git clone https://github.com/valkey-io/valkey.git
-              wsl -d $distroName -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
+              # Install dependencies and Valkey in WSL (using default distribution)
+              wsl -- sudo apt update
+              wsl -- sudo apt install -y build-essential git pkg-config libssl-dev
+              wsl -- git clone https://github.com/valkey-io/valkey.git
+              wsl -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
               
               # Start Valkey server in WSL background
-              wsl -d $distroName -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+              wsl -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 2ce0a06d8d..73d14c0709 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -168,18 +168,17 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Use the known distribution name from installation
-                  $distroName = "Ubuntu 22.04 LTS"
-                  Write-Host "Using WSL distribution: $distroName"
+                  # Use default WSL distribution (no -d flag needed)
+                  Write-Host "Using WSL default distribution"
                   
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d $distroName -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -d $distroName -- redis-cli ping
+                  wsl -- redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -274,18 +273,17 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Use the known distribution name from installation
-                  $distroName = "Ubuntu 22.04 LTS"
-                  Write-Host "Using WSL distribution: $distroName"
+                  # Use default WSL distribution (no -d flag needed)
+                  Write-Host "Using WSL default distribution"
                   
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d $distroName -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -d $distroName -- redis-cli ping
+                  wsl -- redis-cli ping
 
             - name: Test pubsub
               working-directory: java

From 8f5776b95d79229e80a5e29ef7af3e9cc61523de Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 11:01:23 -0700
Subject: [PATCH 009/106] Setup WSL2 using vampire/setup-wsl action

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 42 ++++++++++---------
 .github/workflows/java.yml                    | 16 +++----
 2 files changed, 30 insertions(+), 28 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 9372d96545..1343ee4c82 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -76,32 +76,34 @@ runs:
               rustc --version
               cargo --version
 
-        - name: Setup WSL and install Valkey (Windows + Java)
+        - name: Setup WSL (Windows + Java)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
+          uses: Vampire/setup-wsl@v3
+          with:
+              distribution: Ubuntu-22.04
+              use-cache: false
+
+        - name: Configure WSL2 (Windows + Java)
           shell: pwsh
           if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
           run: |
-              # Install WSL2 with Ubuntu
-              wsl --install --no-launch Ubuntu-22.04
+              # Ensure WSL2 is the default version
               wsl --set-default-version 2
-              
-              # Wait for WSL to be ready
-              Start-Sleep -Seconds 20
-              
-              # Set Ubuntu as default distribution to avoid name issues
-              wsl --set-default "Ubuntu 22.04 LTS"
-              
-              # Verify WSL is working by using default (no -d flag needed)
-              Write-Host "Testing WSL connection..."
-              wsl -- echo "WSL connection successful"
-              
-              # Install dependencies and Valkey in WSL (using default distribution)
-              wsl -- sudo apt update
-              wsl -- sudo apt install -y build-essential git pkg-config libssl-dev
-              wsl -- git clone https://github.com/valkey-io/valkey.git
-              wsl -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
+              # Convert the distribution to WSL2 if it's not already
+              wsl --set-version Ubuntu-22.04 2
+
+        - name: Install Valkey in WSL (Windows + Java)
+          shell: pwsh
+          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
+          run: |
+              # Install dependencies and Valkey in WSL
+              wsl -d Ubuntu-22.04 -- sudo apt update
+              wsl -d Ubuntu-22.04 -- sudo apt install -y build-essential git pkg-config libssl-dev
+              wsl -d Ubuntu-22.04 -- git clone https://github.com/valkey-io/valkey.git
+              wsl -d Ubuntu-22.04 -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
               
               # Start Valkey server in WSL background
-              wsl -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+              wsl -d Ubuntu-22.04 -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 73d14c0709..b5e4938e1c 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -168,17 +168,17 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Use default WSL distribution (no -d flag needed)
-                  Write-Host "Using WSL default distribution"
+                  # Use Ubuntu-22.04 distribution name
+                  Write-Host "Using WSL distribution: Ubuntu-22.04"
                   
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -- redis-cli ping
+                  wsl -d Ubuntu-22.04 -- redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -273,17 +273,17 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
-                  # Use default WSL distribution (no -d flag needed)
-                  Write-Host "Using WSL default distribution"
+                  # Use Ubuntu-22.04 distribution name
+                  Write-Host "Using WSL distribution: Ubuntu-22.04"
                   
                   # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
+                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   
                   # Verify Valkey is running in WSL
-                  wsl -- redis-cli ping
+                  wsl -d Ubuntu-22.04 -- redis-cli ping
 
             - name: Test pubsub
               working-directory: java

From 67f0eaa906e461225a81060b35248c37ab2d94c2 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 11:14:18 -0700
Subject: [PATCH 010/106] Clean-up vampire usage

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml     | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 1343ee4c82..6e182822a3 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -81,21 +81,19 @@ runs:
           uses: Vampire/setup-wsl@v3
           with:
               distribution: Ubuntu-22.04
-              use-cache: false
-
-        - name: Configure WSL2 (Windows + Java)
-          shell: pwsh
-          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
-          run: |
-              # Ensure WSL2 is the default version
-              wsl --set-default-version 2
-              # Convert the distribution to WSL2 if it's not already
-              wsl --set-version Ubuntu-22.04 2
+              use-cache: true
+              update: true
+          env:
+              GITHUB_TOKEN: ${{ inputs.github-token }}
 
         - name: Install Valkey in WSL (Windows + Java)
           shell: pwsh
           if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
           run: |
+              # Verify WSL is working
+              Write-Host "Testing WSL connection..."
+              wsl -d Ubuntu-22.04 -- echo "WSL connection successful"
+              
               # Install dependencies and Valkey in WSL
               wsl -d Ubuntu-22.04 -- sudo apt update
               wsl -d Ubuntu-22.04 -- sudo apt install -y build-essential git pkg-config libssl-dev

From a8bde7f7f257ed69636559c743ec5f30bd445f79 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 11:59:31 -0700
Subject: [PATCH 011/106] Use the shell wrapper after running vampire

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 37 ++++++------------
 .github/workflows/java.yml                    | 38 ++++++++-----------
 2 files changed, 28 insertions(+), 47 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 6e182822a3..00bdecf960 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -76,32 +76,26 @@ runs:
               rustc --version
               cargo --version
 
-        - name: Setup WSL (Windows + Java)
-          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
+        - name: Setup WSL (Windows only)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
           uses: Vampire/setup-wsl@v3
           with:
               distribution: Ubuntu-22.04
               use-cache: true
               update: true
-          env:
-              GITHUB_TOKEN: ${{ inputs.github-token }}
 
-        - name: Install Valkey in WSL (Windows + Java)
-          shell: pwsh
-          if: "${{ inputs.os == 'windows' && inputs.engine-version && inputs.language == 'java' }}"
+        - name: Install engine
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          if: "${{ inputs.engine-version }}"
           run: |
-              # Verify WSL is working
-              Write-Host "Testing WSL connection..."
-              wsl -d Ubuntu-22.04 -- echo "WSL connection successful"
+              # Install dependencies and Valkey
+              sudo apt update
+              sudo apt install -y build-essential git pkg-config libssl-dev
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install
               
-              # Install dependencies and Valkey in WSL
-              wsl -d Ubuntu-22.04 -- sudo apt update
-              wsl -d Ubuntu-22.04 -- sudo apt install -y build-essential git pkg-config libssl-dev
-              wsl -d Ubuntu-22.04 -- git clone https://github.com/valkey-io/valkey.git
-              wsl -d Ubuntu-22.04 -- bash -c "cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install"
-              
-              # Start Valkey server in WSL background
-              wsl -d Ubuntu-22.04 -- redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+              # Start Valkey server in background
+              redis-server --daemonize yes --bind 0.0.0.0 --port 6379
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
@@ -110,13 +104,6 @@ runs:
               target: ${{ inputs.target }}
               github-token: ${{ inputs.github-token }}
 
-        - name: Install engine
-          if: "${{ inputs.engine-version && inputs.os != 'windows' }}"
-          uses: ./.github/workflows/install-engine
-          with:
-              engine-version: ${{ inputs.engine-version }}
-              target: ${{ inputs.target }}
-
         - name: Install zig
           if: ${{ contains(inputs.target, 'linux-gnu') }}
           uses: ./.github/workflows/install-zig
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index b5e4938e1c..0f4379e21e 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -166,19 +166,16 @@ jobs:
 
             - name: Setup WSL networking for tests (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
-              shell: pwsh
+              shell: wsl-bash {0}
               run: |
-                  # Use Ubuntu-22.04 distribution name
-                  Write-Host "Using WSL distribution: Ubuntu-22.04"
+                  # Get WSL IP address from within WSL and set environment variables
+                  WSL_IP=$(hostname -I | awk '{print $1}')
+                  echo "WSL_IP=$WSL_IP" >> $GITHUB_ENV
+                  echo "REDIS_HOST=$WSL_IP" >> $GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $GITHUB_ENV
                   
-                  # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
-                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
-                  
-                  # Verify Valkey is running in WSL
-                  wsl -d Ubuntu-22.04 -- redis-cli ping
+                  # Verify Valkey is running
+                  redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -271,19 +268,16 @@ jobs:
 
             - name: Setup WSL networking for PubSub tests (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
-              shell: pwsh
+              shell: wsl-bash {0}
               run: |
-                  # Use Ubuntu-22.04 distribution name
-                  Write-Host "Using WSL distribution: Ubuntu-22.04"
-                  
-                  # Get WSL IP address and set environment variable for tests
-                  $wslIp = wsl -d Ubuntu-22.04 -- hostname -I | ForEach-Object { $_.Trim().Split(' ')[0] }
-                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
+                  # Get WSL IP address from within WSL and set environment variables
+                  WSL_IP=$(hostname -I | awk '{print $1}')
+                  echo "WSL_IP=$WSL_IP" >> $GITHUB_ENV
+                  echo "REDIS_HOST=$WSL_IP" >> $GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $GITHUB_ENV
                   
-                  # Verify Valkey is running in WSL
-                  wsl -d Ubuntu-22.04 -- redis-cli ping
+                  # Verify Valkey is running
+                  redis-cli ping
 
             - name: Test pubsub
               working-directory: java

From 10406e7ee9b3efefb81940708205ea7a2e94ace8 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 12:25:40 -0700
Subject: [PATCH 012/106] Rework tracking of IP for tests

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    |  5 +++
 .github/workflows/java.yml                    | 34 ++++++++++---------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 00bdecf960..6be58ed82c 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -96,6 +96,11 @@ runs:
               
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+              
+              # For Windows, write IP to a file that PowerShell can read
+              if [ "${{ inputs.os }}" = "windows" ]; then
+                  hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
+              fi
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 0f4379e21e..ffeefafe31 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -164,18 +164,19 @@ jobs:
                       ./gradlew --build-cache --continue build -x javadoc
                   fi
 
-            - name: Setup WSL networking for tests (Windows)
+            - name: Setup networking and verify Valkey (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
-              shell: wsl-bash {0}
+              shell: pwsh
               run: |
-                  # Get WSL IP address from within WSL and set environment variables
-                  WSL_IP=$(hostname -I | awk '{print $1}')
-                  echo "WSL_IP=$WSL_IP" >> $GITHUB_ENV
-                  echo "REDIS_HOST=$WSL_IP" >> $GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $GITHUB_ENV
+                  # Read WSL IP from file written by engine installation
+                  $wslIp = wsl -c "cat /tmp/wsl_ip.txt"
+                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
+                  Write-Host "WSL IP address: $wslIp"
                   
                   # Verify Valkey is running
-                  redis-cli ping
+                  wsl -c "redis-cli ping"
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -266,18 +267,19 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
-            - name: Setup WSL networking for PubSub tests (Windows)
+            - name: Setup networking and verify Valkey for PubSub (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
-              shell: wsl-bash {0}
+              shell: pwsh
               run: |
-                  # Get WSL IP address from within WSL and set environment variables
-                  WSL_IP=$(hostname -I | awk '{print $1}')
-                  echo "WSL_IP=$WSL_IP" >> $GITHUB_ENV
-                  echo "REDIS_HOST=$WSL_IP" >> $GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $GITHUB_ENV
+                  # Read WSL IP from file written by engine installation
+                  $wslIp = wsl -c "cat /tmp/wsl_ip.txt"
+                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
+                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
+                  Write-Host "WSL IP address: $wslIp"
                   
                   # Verify Valkey is running
-                  redis-cli ping
+                  wsl -c "redis-cli ping"
 
             - name: Test pubsub
               working-directory: java

From efc5b6e53ed9f50750a80824e4305f11e5794c6d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 12:47:08 -0700
Subject: [PATCH 013/106] Remove apt-update when installing the engine and use
 newer vampire

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 6be58ed82c..e3c2964ad1 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -78,18 +78,16 @@ runs:
 
         - name: Setup WSL (Windows only)
           if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
-          uses: Vampire/setup-wsl@v3
+          uses: Vampire/setup-wsl@v6
           with:
               distribution: Ubuntu-22.04
               use-cache: true
-              update: true
 
         - name: Install engine
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
           run: |
               # Install dependencies and Valkey
-              sudo apt update
               sudo apt install -y build-essential git pkg-config libssl-dev
               git clone https://github.com/valkey-io/valkey.git
               cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install

From 8f128c140d76fd34784f6b059405ff9a79628741 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 12:47:23 -0700
Subject: [PATCH 014/106] Fix syntax error when getting WSL IP

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index ffeefafe31..aa4de9c773 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -169,14 +169,14 @@ jobs:
               shell: pwsh
               run: |
                   # Read WSL IP from file written by engine installation
-                  $wslIp = wsl -c "cat /tmp/wsl_ip.txt"
+                  $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
                   
                   # Verify Valkey is running
-                  wsl -c "redis-cli ping"
+                  wsl -- redis-cli ping
 
             - name: Ensure no skipped files by linter
               working-directory: java
@@ -272,14 +272,14 @@ jobs:
               shell: pwsh
               run: |
                   # Read WSL IP from file written by engine installation
-                  $wslIp = wsl -c "cat /tmp/wsl_ip.txt"
+                  $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
                   
                   # Verify Valkey is running
-                  wsl -c "redis-cli ping"
+                  wsl -- redis-cli ping
 
             - name: Test pubsub
               working-directory: java

From bc425cf162e926c1dc486bed6bf1c015d253020d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 12:52:02 -0700
Subject: [PATCH 015/106] Use vampire update to fix missing repo errors

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index e3c2964ad1..b111da15c6 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -82,6 +82,7 @@ runs:
           with:
               distribution: Ubuntu-22.04
               use-cache: true
+              update: true
 
         - name: Install engine
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}

From 7b669610c1f56e64dabddb8b93b9e4e0aeaf69a1 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 13:10:46 -0700
Subject: [PATCH 016/106] Speed up valkey build

- Parallelize the build
- Cache by OS and commit hash

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 31 ++++++++++++++++---
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index b111da15c6..24940f3dce 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -83,15 +83,38 @@ runs:
               distribution: Ubuntu-22.04
               use-cache: true
               update: true
+              additional-packages: build-essential git pkg-config libssl-dev
+
+        - name: Cache Valkey build
+          if: "${{ inputs.engine-version }}"
+          uses: actions/cache@v4
+          id: cache-valkey
+          with:
+              path: |
+                  valkey/src/redis-server
+                  valkey/src/redis-cli
+                  valkey/src/redis-benchmark
+              key: valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-${{ github.sha }}
+              restore-keys: |
+                  valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
 
         - name: Install engine
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
           run: |
-              # Install dependencies and Valkey
-              sudo apt install -y build-essential git pkg-config libssl-dev
-              git clone https://github.com/valkey-io/valkey.git
-              cd valkey && git checkout ${{ inputs.engine-version }} && make BUILD_TLS=yes && sudo make install
+              # Check if Valkey binaries are cached
+              if [ "${{ steps.cache-valkey.outputs.cache-hit }}" = "true" ]; then
+                  echo "Using cached Valkey binaries"
+                  cd valkey && sudo make install
+              else
+                  echo "Building Valkey from source"
+                  # Install dependencies (only needed on Linux, Windows handled by Vampire)
+                  if [ "${{ inputs.os }}" != "windows" ]; then
+                      sudo apt install -y build-essential git pkg-config libssl-dev
+                  fi
+                  git clone https://github.com/valkey-io/valkey.git
+                  cd valkey && git checkout ${{ inputs.engine-version }} && make -j$(nproc) BUILD_TLS=yes && sudo make install
+              fi
               
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379

From 26ec32c0085bc653f2ad08cfa2b0e1f704e17a4d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 13:16:37 -0700
Subject: [PATCH 017/106] Fix missing python3 on Windows

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 24940f3dce..4d7bdd0c31 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -76,6 +76,12 @@ runs:
               rustc --version
               cargo --version
 
+        - name: Setup Python for Windows
+          if: "${{ inputs.os == 'windows' }}"
+          uses: actions/setup-python@v5
+          with:
+              python-version: '3.x'
+
         - name: Setup WSL (Windows only)
           if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
           uses: Vampire/setup-wsl@v6

From a3681a0af405dea168fa5e1d1124c7063239f7ec Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 13:18:01 -0700
Subject: [PATCH 018/106] Parallelize the cargo build within gradle

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index aa4de9c773..b487981789 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -156,6 +156,8 @@ jobs:
 
             - name: Build java client
               working-directory: java
+              env:
+                  CARGO_BUILD_JOBS: 0  # Use all available cores
               shell: bash
               run: |
                   if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
@@ -410,6 +412,7 @@ jobs:
               working-directory: java
               env:
                   GLIDE_CONTAINER_BUILD: true
+                  CARGO_BUILD_JOBS: 0  # Use all available cores
               run: |
                   if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
                       export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-amazon-corretto.x86_64

From 2819844bd025f026925cde8bbc1e5f15ff9b53ce Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 13:24:57 -0700
Subject: [PATCH 019/106] Fix up cargo parallelization

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index b487981789..b7aebcdb2b 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -157,7 +157,7 @@ jobs:
             - name: Build java client
               working-directory: java
               env:
-                  CARGO_BUILD_JOBS: 0  # Use all available cores
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
               shell: bash
               run: |
                   if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
@@ -412,7 +412,7 @@ jobs:
               working-directory: java
               env:
                   GLIDE_CONTAINER_BUILD: true
-                  CARGO_BUILD_JOBS: 0  # Use all available cores
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
               run: |
                   if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
                       export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-amazon-corretto.x86_64

From 78d421bd07d6f60ac080fcc4d0949ec3a60f0536 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 13:56:47 -0700
Subject: [PATCH 020/106] Handle the Windows native binaries in NativeUtils and
 gradle

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/client/build.gradle                                  | 8 ++++++++
 .../src/main/java/glide/ffi/resolvers/NativeUtils.java    | 4 +++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/java/client/build.gradle b/java/client/build.gradle
index 5b08b319d3..41520180df 100644
--- a/java/client/build.gradle
+++ b/java/client/build.gradle
@@ -103,6 +103,8 @@ tasks.register('buildRust', Exec) {
             target = "${arch}-unknown-linux-gnu.2.17"
         } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
             target = "${arch}-unknown-linux-musl"
+        } else if (osdetector.os == 'windows') {
+            target = "${arch}-pc-windows-msvc"
         } else {
             target = ""
         }
@@ -114,6 +116,8 @@ tasks.register('buildRust', Exec) {
     } else if (target.contains("musl")) {
         commandLine 'cargo', 'zigbuild', '--target', "$target", '--release'
         environment RUSTFLAGS: '-C target-feature=-crt-static'
+    } else if (target.contains("windows")) {
+        commandLine 'cargo', 'build', '--target', "$target", '--release'
     } else {
         commandLine 'cargo', 'build', '--release'
     }
@@ -148,6 +152,8 @@ tasks.register('copyNativeLib', Copy) {
         from "${projectDir}/../target/${arch}-unknown-linux-gnu/release/"
     } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
         from "${projectDir}/../target/${arch}-unknown-linux-musl/release/"
+    } else if (osdetector.os == 'windows') {
+        from "${projectDir}/../target/${arch}-pc-windows-msvc/release/"
     } else {
         from "${projectDir}/../target/release/"
     }
@@ -254,6 +260,8 @@ tasks.withType(Test) {
         jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-unknown-linux-gnu/release"
     } else if (osdetector.os == 'linux' && osdetector.release.id == 'alpine') {
         jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-unknown-linux-musl/release"
+    } else if (osdetector.os == 'windows') {
+        jvmArgs "-Djava.library.path=${projectDir}/../target/${arch}-pc-windows-msvc/release"
     } else {
         jvmArgs "-Djava.library.path=${projectDir}/../target/release"
     }
diff --git a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
index 071bc8e615..6d3a9e2800 100644
--- a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
+++ b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
@@ -42,9 +42,11 @@ public static void loadGlideLib() {
                 NativeUtils.loadLibraryFromJar(glideLib + ".dylib");
             } else if (osName.contains("linux")) {
                 NativeUtils.loadLibraryFromJar(glideLib + ".so");
+            } else if (osName.contains("windows")) {
+                NativeUtils.loadLibraryFromJar("/glide_rs.dll");
             } else {
                 throw new UnsupportedOperationException(
-                        "OS not supported. Glide is only available on Mac OS and Linux systems.");
+                        "OS not supported. Glide is only available on Mac OS, Linux, and Windows systems.");
             }
         } catch (java.io.IOException e) {
             e.printStackTrace();

From 70aa3a609a0f82790b10f05352216ea82ac954da Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:04:53 -0700
Subject: [PATCH 021/106] Fix cache hit on valkey server

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 4d7bdd0c31..4a847e6064 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -111,7 +111,9 @@ runs:
               # Check if Valkey binaries are cached
               if [ "${{ steps.cache-valkey.outputs.cache-hit }}" = "true" ]; then
                   echo "Using cached Valkey binaries"
-                  cd valkey && sudo make install
+                  # Clone repo for make install to work
+                  git clone https://github.com/valkey-io/valkey.git
+                  cd valkey && git checkout ${{ inputs.engine-version }} && sudo make install
               else
                   echo "Building Valkey from source"
                   # Install dependencies (only needed on Linux, Windows handled by Vampire)

From f6e22d9ad27afa86c59ae96cf0527ff9980c2bd5 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:05:41 -0700
Subject: [PATCH 022/106] Fix semgrep warning

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml         | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 4a847e6064..195eaffaa3 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -107,28 +107,32 @@ runs:
         - name: Install engine
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
+          env:
+              CACHE_HIT: ${{ steps.cache-valkey.outputs.cache-hit }}
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
           run: |
               # Check if Valkey binaries are cached
-              if [ "${{ steps.cache-valkey.outputs.cache-hit }}" = "true" ]; then
+              if [ "$CACHE_HIT" = "true" ]; then
                   echo "Using cached Valkey binaries"
                   # Clone repo for make install to work
                   git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout ${{ inputs.engine-version }} && sudo make install
+                  cd valkey && git checkout "$ENGINE_VERSION" && sudo make install
               else
                   echo "Building Valkey from source"
                   # Install dependencies (only needed on Linux, Windows handled by Vampire)
-                  if [ "${{ inputs.os }}" != "windows" ]; then
+                  if [ "$OS_TYPE" != "windows" ]; then
                       sudo apt install -y build-essential git pkg-config libssl-dev
                   fi
                   git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout ${{ inputs.engine-version }} && make -j$(nproc) BUILD_TLS=yes && sudo make install
+                  cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes && sudo make install
               fi
               
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379
               
               # For Windows, write IP to a file that PowerShell can read
-              if [ "${{ inputs.os }}" = "windows" ]; then
+              if [ "$OS_TYPE" = "windows" ]; then
                   hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
               fi
 

From 2d63ce9a4a913e4661c44f3b6b3bdc5cc8a994f3 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:06:14 -0700
Subject: [PATCH 023/106] Run prettier

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 6 +++---
 .github/workflows/java.yml                               | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 195eaffaa3..d9a47fa5b8 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -80,7 +80,7 @@ runs:
           if: "${{ inputs.os == 'windows' }}"
           uses: actions/setup-python@v5
           with:
-              python-version: '3.x'
+              python-version: "3.x"
 
         - name: Setup WSL (Windows only)
           if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
@@ -127,10 +127,10 @@ runs:
                   git clone https://github.com/valkey-io/valkey.git
                   cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes && sudo make install
               fi
-              
+
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379
-              
+
               # For Windows, write IP to a file that PowerShell can read
               if [ "$OS_TYPE" = "windows" ]; then
                   hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index b7aebcdb2b..b8fe54f6c6 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -176,7 +176,7 @@ jobs:
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
-                  
+
                   # Verify Valkey is running
                   wsl -- redis-cli ping
 
@@ -279,7 +279,7 @@ jobs:
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
-                  
+
                   # Verify Valkey is running
                   wsl -- redis-cli ping
 

From 524bb5f1d3c2f36373afea5856c54e0dde78f05b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:16:22 -0700
Subject: [PATCH 024/106] Fix conflicting directory name when there's a cache
 hit on valkey server

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index d9a47fa5b8..ff28dcd9cb 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -115,7 +115,8 @@ runs:
               # Check if Valkey binaries are cached
               if [ "$CACHE_HIT" = "true" ]; then
                   echo "Using cached Valkey binaries"
-                  # Clone repo for make install to work
+                  # Remove any existing valkey directory and clone fresh
+                  rm -rf valkey
                   git clone https://github.com/valkey-io/valkey.git
                   cd valkey && git checkout "$ENGINE_VERSION" && sudo make install
               else

From eb9dac46882b7d5108c46179aee945b030d1b439 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:22:26 -0700
Subject: [PATCH 025/106] Fix file conflict when getting valkey server from
 cache

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 23 +++++++++++++------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index ff28dcd9cb..ad91f2b1fe 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -97,9 +97,9 @@ runs:
           id: cache-valkey
           with:
               path: |
-                  valkey/src/redis-server
-                  valkey/src/redis-cli
-                  valkey/src/redis-benchmark
+                  valkey-cache/redis-server
+                  valkey-cache/redis-cli
+                  valkey-cache/redis-benchmark
               key: valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-${{ github.sha }}
               restore-keys: |
                   valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
@@ -115,10 +115,14 @@ runs:
               # Check if Valkey binaries are cached
               if [ "$CACHE_HIT" = "true" ]; then
                   echo "Using cached Valkey binaries"
-                  # Remove any existing valkey directory and clone fresh
-                  rm -rf valkey
+                  # Clone repo fresh
                   git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout "$ENGINE_VERSION" && sudo make install
+                  cd valkey && git checkout "$ENGINE_VERSION"
+                  # Move cached binaries to correct location (force overwrite)
+                  mkdir -p src
+                  cp -f ../valkey-cache/* src/ 2>/dev/null || true
+                  # Install the cached binaries
+                  sudo make install
               else
                   echo "Building Valkey from source"
                   # Install dependencies (only needed on Linux, Windows handled by Vampire)
@@ -126,7 +130,12 @@ runs:
                       sudo apt install -y build-essential git pkg-config libssl-dev
                   fi
                   git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes && sudo make install
+                  cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
+                  # Cache the built binaries
+                  mkdir -p ../valkey-cache
+                  cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/
+                  # Install the binaries
+                  sudo make install
               fi
 
               # Start Valkey server in background

From 4f352afe249540fbf55e802592aa32b8d068d2a0 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:39:19 -0700
Subject: [PATCH 026/106] Cache rust, ziglang, protoc

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-protoc-cached/action.yml          | 26 ++++++++++++++
 .../install-rust-and-protoc/action.yml        | 17 ++++++++--
 .github/workflows/install-zig/action.yml      | 17 ++++++++++
 .github/workflows/java.yml                    | 34 +++++++++++++------
 4 files changed, 81 insertions(+), 13 deletions(-)
 create mode 100644 .github/workflows/install-protoc-cached/action.yml

diff --git a/.github/workflows/install-protoc-cached/action.yml b/.github/workflows/install-protoc-cached/action.yml
new file mode 100644
index 0000000000..d75d6f8540
--- /dev/null
+++ b/.github/workflows/install-protoc-cached/action.yml
@@ -0,0 +1,26 @@
+name: Install protoc with caching
+
+inputs:
+    version:
+        description: "Protoc version to install"
+        required: true
+        type: string
+        default: "29.1"
+
+runs:
+    using: "composite"
+    steps:
+        - name: Cache protoc
+          uses: actions/cache@v4
+          id: cache-protoc
+          with:
+              path: |
+                  ~/.local/bin/protoc
+                  ~/.local/include/google
+              key: protoc-${{ inputs.version }}-${{ runner.os }}-${{ runner.arch }}
+
+        - name: Install protoc (protobuf)
+          uses: arduino/setup-protoc@v3
+          with:
+              version: ${{ inputs.version }}
+              repo-token: ${{ github.token }}
diff --git a/.github/workflows/install-rust-and-protoc/action.yml b/.github/workflows/install-rust-and-protoc/action.yml
index a7237effbd..9aa276f5c7 100644
--- a/.github/workflows/install-rust-and-protoc/action.yml
+++ b/.github/workflows/install-rust-and-protoc/action.yml
@@ -20,6 +20,20 @@ inputs:
 runs:
     using: "composite"
     steps:
+        - name: Cache Rust toolchain
+          uses: actions/cache@v4
+          id: cache-rust
+          with:
+              path: |
+                  ~/.rustup
+                  ~/.cargo/bin
+                  ~/.cargo/registry/index
+                  ~/.cargo/registry/cache
+                  ~/.cargo/git
+              key: rust-${{ inputs.target }}-${{ runner.os }}-v1
+              restore-keys: |
+                  rust-${{ inputs.target }}-${{ runner.os }}-
+
         - name: Install Rust toolchain
           uses: dtolnay/rust-toolchain@stable
           with:
@@ -27,7 +41,6 @@ runs:
               components: rustfmt, clippy
 
         - name: Install protoc (protobuf)
-          uses: arduino/setup-protoc@v3
+          uses: ./.github/workflows/install-protoc-cached
           with:
               version: "25.1"
-              repo-token: ${{ inputs.github-token }}
diff --git a/.github/workflows/install-zig/action.yml b/.github/workflows/install-zig/action.yml
index 844ef0f16e..a58146760a 100644
--- a/.github/workflows/install-zig/action.yml
+++ b/.github/workflows/install-zig/action.yml
@@ -10,7 +10,19 @@ inputs:
 runs:
     using: "composite"
     steps:
+        - name: Cache zig installation
+          uses: actions/cache@v4
+          id: cache-zig
+          with:
+              path: |
+                  ~/.local/bin/zig
+                  ~/.cargo/bin/cargo-zigbuild
+              key: zig-${{ runner.os }}-${{ runner.arch }}-v1
+              restore-keys: |
+                  zig-${{ runner.os }}-${{ runner.arch }}-
+
         - name: Install zig
+          if: steps.cache-zig.outputs.cache-hit != 'true'
           shell: bash
           env:
               TARGET: ${{ inputs.target }}
@@ -27,6 +39,11 @@ runs:
               fi
               cargo install --locked cargo-zigbuild
 
+        - name: Set zig environment
+          shell: bash
+          env:
+              TARGET: ${{ inputs.target }}
+          run: |
               # Set environment variable to prevent cargo-zigbuild from auto-detecting malformed targets
               # This will be available for subsequent steps in the workflow
               echo "CARGO_ZIGBUILD_TARGET=$TARGET" >> $GITHUB_ENV
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index b8fe54f6c6..6abe92dfba 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -129,10 +129,9 @@ jobs:
                   language: java
 
             - name: Install protoc (protobuf)
-              uses: arduino/setup-protoc@v3
+              uses: ./.github/workflows/install-protoc-cached
               with:
                   version: "29.1"
-                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:
@@ -244,10 +243,9 @@ jobs:
                   language: java
 
             - name: Install protoc (protobuf)
-              uses: arduino/setup-protoc@v3
+              uses: ./.github/workflows/install-protoc-cached
               with:
                   version: "29.1"
-                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:
@@ -373,21 +371,36 @@ jobs:
                   engine-version: ${{ matrix.engine.version }}
 
             - name: Install protoc (protobuf)
-              uses: arduino/setup-protoc@v3
+              uses: ./.github/workflows/install-protoc-cached
               with:
                   version: "29.1"
-                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             # Ensure Rust is in PATH for container environments
+            - name: Cache zig installation (musl)
+              if: ${{ contains(matrix.host.TARGET, 'musl') }}
+              uses: actions/cache@v4
+              id: cache-zig-musl
+              with:
+                  path: |
+                      ~/.local/bin/zig
+                      ~/.cargo/bin/cargo-zigbuild
+                  key: zig-musl-${{ runner.os }}-${{ runner.arch }}-v1
+                  restore-keys: |
+                      zig-musl-${{ runner.os }}-${{ runner.arch }}-
+
             - name: Setup Rust Build
               if: ${{ contains(matrix.host.TARGET, 'musl') }}
+              env:
+                  CACHE_HIT: ${{ steps.cache-zig-musl.outputs.cache-hit }}
               run: |
                   export PATH="$HOME/.cargo/bin:$PATH"
                   echo "PATH=$HOME/.cargo/bin:$PATH" >> $GITHUB_ENV
 
-                  # Install ziglang and zigbuild
-                  pip3 install ziglang --break-system-packages
-                  cargo install --locked cargo-zigbuild
+                  # Install ziglang and zigbuild (only if not cached)
+                  if [ "$CACHE_HIT" != "true" ]; then
+                      pip3 install ziglang --break-system-packages
+                      cargo install --locked cargo-zigbuild
+                  fi
 
             - uses: actions/cache@v4
               with:
@@ -468,10 +481,9 @@ jobs:
                   java-version: 17
 
             - name: Install protoc (protobuf)
-              uses: arduino/setup-protoc@v3
+              uses: ./.github/workflows/install-protoc-cached
               with:
                   version: "29.1"
-                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:

From 732c4a1478bd68395892479324c85cd4925b53ae Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:40:59 -0700
Subject: [PATCH 027/106] Use valkey server names when caching

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index ad91f2b1fe..4f0e170bf8 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -97,9 +97,9 @@ runs:
           id: cache-valkey
           with:
               path: |
-                  valkey-cache/redis-server
-                  valkey-cache/redis-cli
-                  valkey-cache/redis-benchmark
+                  valkey-cache/valkey-server
+                  valkey-cache/valkey-cli
+                  valkey-cache/valkey-benchmark
               key: valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-${{ github.sha }}
               restore-keys: |
                   valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
@@ -133,7 +133,7 @@ runs:
                   cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
                   # Cache the built binaries
                   mkdir -p ../valkey-cache
-                  cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/
+                  cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/
                   # Install the binaries
                   sudo make install
               fi

From 20bb48b76da118e7635208b2891f8f9db3ad5da2 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 14:50:59 -0700
Subject: [PATCH 028/106] Handle redis and valkey server binary names

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../workflows/install-shared-dependencies/action.yml | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 4f0e170bf8..a56a514622 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -131,9 +131,17 @@ runs:
                   fi
                   git clone https://github.com/valkey-io/valkey.git
                   cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
-                  # Cache the built binaries
+                  # Cache the built binaries - detect which naming convention is used
                   mkdir -p ../valkey-cache
-                  cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/
+                  if [ -f "src/valkey-server" ]; then
+                      echo "Found Valkey binaries"
+                      cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/ 2>/dev/null || true
+                  elif [ -f "src/redis-server" ]; then
+                      echo "Found Redis binaries"
+                      cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/ 2>/dev/null || true
+                  else
+                      echo "Warning: No server binaries found to cache"
+                  fi
                   # Install the binaries
                   sudo make install
               fi

From 0f7df0dbf2102ca963d588ea5ec6609f1f0db8d1 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 15:04:40 -0700
Subject: [PATCH 029/106] Revert caching of build tools

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-protoc-cached/action.yml          | 26 --------------
 .../install-rust-and-protoc/action.yml        | 17 ++--------
 .github/workflows/install-zig/action.yml      | 17 ----------
 .github/workflows/java.yml                    | 34 ++++++-------------
 4 files changed, 13 insertions(+), 81 deletions(-)
 delete mode 100644 .github/workflows/install-protoc-cached/action.yml

diff --git a/.github/workflows/install-protoc-cached/action.yml b/.github/workflows/install-protoc-cached/action.yml
deleted file mode 100644
index d75d6f8540..0000000000
--- a/.github/workflows/install-protoc-cached/action.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: Install protoc with caching
-
-inputs:
-    version:
-        description: "Protoc version to install"
-        required: true
-        type: string
-        default: "29.1"
-
-runs:
-    using: "composite"
-    steps:
-        - name: Cache protoc
-          uses: actions/cache@v4
-          id: cache-protoc
-          with:
-              path: |
-                  ~/.local/bin/protoc
-                  ~/.local/include/google
-              key: protoc-${{ inputs.version }}-${{ runner.os }}-${{ runner.arch }}
-
-        - name: Install protoc (protobuf)
-          uses: arduino/setup-protoc@v3
-          with:
-              version: ${{ inputs.version }}
-              repo-token: ${{ github.token }}
diff --git a/.github/workflows/install-rust-and-protoc/action.yml b/.github/workflows/install-rust-and-protoc/action.yml
index 9aa276f5c7..a7237effbd 100644
--- a/.github/workflows/install-rust-and-protoc/action.yml
+++ b/.github/workflows/install-rust-and-protoc/action.yml
@@ -20,20 +20,6 @@ inputs:
 runs:
     using: "composite"
     steps:
-        - name: Cache Rust toolchain
-          uses: actions/cache@v4
-          id: cache-rust
-          with:
-              path: |
-                  ~/.rustup
-                  ~/.cargo/bin
-                  ~/.cargo/registry/index
-                  ~/.cargo/registry/cache
-                  ~/.cargo/git
-              key: rust-${{ inputs.target }}-${{ runner.os }}-v1
-              restore-keys: |
-                  rust-${{ inputs.target }}-${{ runner.os }}-
-
         - name: Install Rust toolchain
           uses: dtolnay/rust-toolchain@stable
           with:
@@ -41,6 +27,7 @@ runs:
               components: rustfmt, clippy
 
         - name: Install protoc (protobuf)
-          uses: ./.github/workflows/install-protoc-cached
+          uses: arduino/setup-protoc@v3
           with:
               version: "25.1"
+              repo-token: ${{ inputs.github-token }}
diff --git a/.github/workflows/install-zig/action.yml b/.github/workflows/install-zig/action.yml
index a58146760a..844ef0f16e 100644
--- a/.github/workflows/install-zig/action.yml
+++ b/.github/workflows/install-zig/action.yml
@@ -10,19 +10,7 @@ inputs:
 runs:
     using: "composite"
     steps:
-        - name: Cache zig installation
-          uses: actions/cache@v4
-          id: cache-zig
-          with:
-              path: |
-                  ~/.local/bin/zig
-                  ~/.cargo/bin/cargo-zigbuild
-              key: zig-${{ runner.os }}-${{ runner.arch }}-v1
-              restore-keys: |
-                  zig-${{ runner.os }}-${{ runner.arch }}-
-
         - name: Install zig
-          if: steps.cache-zig.outputs.cache-hit != 'true'
           shell: bash
           env:
               TARGET: ${{ inputs.target }}
@@ -39,11 +27,6 @@ runs:
               fi
               cargo install --locked cargo-zigbuild
 
-        - name: Set zig environment
-          shell: bash
-          env:
-              TARGET: ${{ inputs.target }}
-          run: |
               # Set environment variable to prevent cargo-zigbuild from auto-detecting malformed targets
               # This will be available for subsequent steps in the workflow
               echo "CARGO_ZIGBUILD_TARGET=$TARGET" >> $GITHUB_ENV
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 6abe92dfba..b8fe54f6c6 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -129,9 +129,10 @@ jobs:
                   language: java
 
             - name: Install protoc (protobuf)
-              uses: ./.github/workflows/install-protoc-cached
+              uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:
@@ -243,9 +244,10 @@ jobs:
                   language: java
 
             - name: Install protoc (protobuf)
-              uses: ./.github/workflows/install-protoc-cached
+              uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:
@@ -371,36 +373,21 @@ jobs:
                   engine-version: ${{ matrix.engine.version }}
 
             - name: Install protoc (protobuf)
-              uses: ./.github/workflows/install-protoc-cached
+              uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             # Ensure Rust is in PATH for container environments
-            - name: Cache zig installation (musl)
-              if: ${{ contains(matrix.host.TARGET, 'musl') }}
-              uses: actions/cache@v4
-              id: cache-zig-musl
-              with:
-                  path: |
-                      ~/.local/bin/zig
-                      ~/.cargo/bin/cargo-zigbuild
-                  key: zig-musl-${{ runner.os }}-${{ runner.arch }}-v1
-                  restore-keys: |
-                      zig-musl-${{ runner.os }}-${{ runner.arch }}-
-
             - name: Setup Rust Build
               if: ${{ contains(matrix.host.TARGET, 'musl') }}
-              env:
-                  CACHE_HIT: ${{ steps.cache-zig-musl.outputs.cache-hit }}
               run: |
                   export PATH="$HOME/.cargo/bin:$PATH"
                   echo "PATH=$HOME/.cargo/bin:$PATH" >> $GITHUB_ENV
 
-                  # Install ziglang and zigbuild (only if not cached)
-                  if [ "$CACHE_HIT" != "true" ]; then
-                      pip3 install ziglang --break-system-packages
-                      cargo install --locked cargo-zigbuild
-                  fi
+                  # Install ziglang and zigbuild
+                  pip3 install ziglang --break-system-packages
+                  cargo install --locked cargo-zigbuild
 
             - uses: actions/cache@v4
               with:
@@ -481,9 +468,10 @@ jobs:
                   java-version: 17
 
             - name: Install protoc (protobuf)
-              uses: ./.github/workflows/install-protoc-cached
+              uses: arduino/setup-protoc@v3
               with:
                   version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
 
             - uses: actions/cache@v4
               with:

From 4038e0324a8b5c02159d5efb7d9c59e8112214a4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 15:22:51 -0700
Subject: [PATCH 030/106] Fix unrelated cbindgen issue

Signed-off-by: James Duong <duong.james@gmail.com>
---
 go/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go/Makefile b/go/Makefile
index 03c3b51dc6..7e125d2f45 100644
--- a/go/Makefile
+++ b/go/Makefile
@@ -64,7 +64,7 @@ endif
 
 install-build-tools:
 	go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.33.0
-	cargo install cbindgen
+	cargo install cbindgen@0.26.0
 
 install-dev-tools:
 	go install github.com/vakenbolt/go-test-report@v0.9.3

From b7a6f6dac00f33f0d3335b22eedb4cf0380d2fc0 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 15:23:37 -0700
Subject: [PATCH 031/106] Fix cache miss on valkey-server

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index a56a514622..75a1ad4876 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -108,7 +108,7 @@ runs:
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
           env:
-              CACHE_HIT: ${{ steps.cache-valkey.outputs.cache-hit }}
+              CACHE_HIT: ${{ steps.cache-valkey.outputs.cache-hit || 'false' }}
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
           run: |

From ed9050f8b4d3e6b1965714fa944320277f3b6eea Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 15:35:08 -0700
Subject: [PATCH 032/106] Fix for valkey server cache miss

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 76 +++++++++++--------
 1 file changed, 43 insertions(+), 33 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 75a1ad4876..0bc22d8728 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -106,45 +106,55 @@ runs:
 
         - name: Install engine
           shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
-          if: "${{ inputs.engine-version }}"
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit == 'true' }}"
+          env:
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
+          run: |
+              echo "Using cached Valkey binaries"
+              # Clone repo fresh
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION"
+              # Move cached binaries to correct location (force overwrite)
+              mkdir -p src
+              cp -f ../valkey-cache/* src/ 2>/dev/null || true
+              # Install the cached binaries
+              sudo make install
+
+        - name: Build engine from source
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit != 'true' }}"
           env:
-              CACHE_HIT: ${{ steps.cache-valkey.outputs.cache-hit || 'false' }}
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
           run: |
-              # Check if Valkey binaries are cached
-              if [ "$CACHE_HIT" = "true" ]; then
-                  echo "Using cached Valkey binaries"
-                  # Clone repo fresh
-                  git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout "$ENGINE_VERSION"
-                  # Move cached binaries to correct location (force overwrite)
-                  mkdir -p src
-                  cp -f ../valkey-cache/* src/ 2>/dev/null || true
-                  # Install the cached binaries
-                  sudo make install
+              echo "Building Valkey from source"
+              # Install dependencies (only needed on Linux, Windows handled by Vampire)
+              if [ "$OS_TYPE" != "windows" ]; then
+                  sudo apt install -y build-essential git pkg-config libssl-dev
+              fi
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
+              # Cache the built binaries - detect which naming convention is used
+              mkdir -p ../valkey-cache
+              if [ -f "src/valkey-server" ]; then
+                  echo "Found Valkey binaries"
+                  cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/ 2>/dev/null || true
+              elif [ -f "src/redis-server" ]; then
+                  echo "Found Redis binaries"
+                  cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/ 2>/dev/null || true
               else
-                  echo "Building Valkey from source"
-                  # Install dependencies (only needed on Linux, Windows handled by Vampire)
-                  if [ "$OS_TYPE" != "windows" ]; then
-                      sudo apt install -y build-essential git pkg-config libssl-dev
-                  fi
-                  git clone https://github.com/valkey-io/valkey.git
-                  cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
-                  # Cache the built binaries - detect which naming convention is used
-                  mkdir -p ../valkey-cache
-                  if [ -f "src/valkey-server" ]; then
-                      echo "Found Valkey binaries"
-                      cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/ 2>/dev/null || true
-                  elif [ -f "src/redis-server" ]; then
-                      echo "Found Redis binaries"
-                      cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/ 2>/dev/null || true
-                  else
-                      echo "Warning: No server binaries found to cache"
-                  fi
-                  # Install the binaries
-                  sudo make install
+                  echo "Warning: No server binaries found to cache"
               fi
+              # Install the binaries
+              sudo make install
+
+        - name: Start engine server
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          if: "${{ inputs.engine-version }}"
+          env:
+              OS_TYPE: ${{ inputs.os }}
+          run: |
 
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379

From deda47656fe60082195ce93c024e99cc843380a4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 16:15:38 -0700
Subject: [PATCH 033/106] Set variables using WSLENV

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 0bc22d8728..a032ee0917 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -112,6 +112,8 @@ runs:
               OS_TYPE: ${{ inputs.os }}
           run: |
               echo "Using cached Valkey binaries"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
               # Clone repo fresh
               git clone https://github.com/valkey-io/valkey.git
               cd valkey && git checkout "$ENGINE_VERSION"
@@ -127,8 +129,11 @@ runs:
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
+              WSLENV: ENGINE_VERSION:OS_TYPE
           run: |
               echo "Building Valkey from source"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
               # Install dependencies (only needed on Linux, Windows handled by Vampire)
               if [ "$OS_TYPE" != "windows" ]; then
                   sudo apt install -y build-essential git pkg-config libssl-dev
@@ -155,6 +160,8 @@ runs:
           env:
               OS_TYPE: ${{ inputs.os }}
           run: |
+              echo "Starting Valkey server"
+              echo "OS_TYPE: '$OS_TYPE'"
 
               # Start Valkey server in background
               redis-server --daemonize yes --bind 0.0.0.0 --port 6379

From cf144412055fe7f586057654da80fc6b8ac05391 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 16:38:27 -0700
Subject: [PATCH 034/106] Fix cbindgen issue

Signed-off-by: James Duong <duong.james@gmail.com>
---
 go/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go/Makefile b/go/Makefile
index 7e125d2f45..a767fa41ec 100644
--- a/go/Makefile
+++ b/go/Makefile
@@ -64,7 +64,7 @@ endif
 
 install-build-tools:
 	go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.33.0
-	cargo install cbindgen@0.26.0
+	cargo install cbindgen@0.24.3
 
 install-dev-tools:
 	go install github.com/vakenbolt/go-test-report@v0.9.3

From 9c3aa3d414397fc2994c55bdda7fcec3b980503d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 16:38:36 -0700
Subject: [PATCH 035/106] Propagate more properties to WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index a032ee0917..cebbfde6c3 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -110,6 +110,7 @@ runs:
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
+              WSLENV: ENGINE_VERSION:OS_TYPE
           run: |
               echo "Using cached Valkey binaries"
               echo "OS_TYPE: '$OS_TYPE'"
@@ -159,6 +160,7 @@ runs:
           if: "${{ inputs.engine-version }}"
           env:
               OS_TYPE: ${{ inputs.os }}
+              WSLENV: OS_TYPE
           run: |
               echo "Starting Valkey server"
               echo "OS_TYPE: '$OS_TYPE'"

From 8182332ede8ddd7fbaf69c6270552b2838e7a67c Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 16:50:06 -0700
Subject: [PATCH 036/106] Turn off cargo parallelization to see if it helps Go

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/go.yml | 3 +++
 go/Makefile              | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 536254a25b..64e5565eee 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -155,6 +155,7 @@ jobs:
               shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
+                  CARGO_BUILD_JOBS: 1
               run: |
                   if [[ -n "$RC_VERSION" ]]; then
                     make install-tools
@@ -224,6 +225,8 @@ jobs:
 
             - name: Install and run linters
               working-directory: go
+              env:
+                  CARGO_BUILD_JOBS: 1
               run: |
                   make install-dev-tools install-build-tools gen-c-bindings generate-protobuf lint-ci
 
diff --git a/go/Makefile b/go/Makefile
index a767fa41ec..03c3b51dc6 100644
--- a/go/Makefile
+++ b/go/Makefile
@@ -64,7 +64,7 @@ endif
 
 install-build-tools:
 	go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.33.0
-	cargo install cbindgen@0.24.3
+	cargo install cbindgen
 
 install-dev-tools:
 	go install github.com/vakenbolt/go-test-report@v0.9.3

From c41ffca600753df1915cc7c458979f3a189ea572 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 17:08:34 -0700
Subject: [PATCH 037/106] Install python3 on Windows

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index b8fe54f6c6..d4b2f99da6 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -154,6 +154,13 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
+            - name: Setup Python3 for Windows
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: bash
+              run: |
+                  # Create python3 symlink for Windows
+                  ln -sf $(which python) /usr/bin/python3
+
             - name: Build java client
               working-directory: java
               env:

From cb0cea851a79cbd364be2836ed8b4f4ce2cdc704 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 17:10:00 -0700
Subject: [PATCH 038/106] Create batch file wrappers for valkey server commands

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index cebbfde6c3..71b527163c 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -173,6 +173,57 @@ runs:
                   hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
               fi
 
+        - name: Create WSL wrapper scripts for Valkey binaries (Windows)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          shell: pwsh
+          run: |
+              # Create wrapper batch files that call WSL binaries
+              $wrapperDir = "C:\valkey-wrappers"
+              New-Item -ItemType Directory -Force -Path $wrapperDir
+              
+              # Check and create valkey-server.bat
+              if (wsl which valkey-server 2>$null) {
+                  @"
+              @echo off
+              wsl valkey-server %*
+              "@ | Out-File -FilePath "$wrapperDir\valkey-server.bat" -Encoding ASCII
+                  Write-Host "Created valkey-server.bat wrapper"
+              }
+              
+              # Check and create redis-server.bat
+              if (wsl which redis-server 2>$null) {
+                  @"
+              @echo off
+              wsl redis-server %*
+              "@ | Out-File -FilePath "$wrapperDir\redis-server.bat" -Encoding ASCII
+                  Write-Host "Created redis-server.bat wrapper"
+              }
+              
+              # Check and create valkey-cli.bat
+              if (wsl which valkey-cli 2>$null) {
+                  @"
+              @echo off
+              wsl valkey-cli %*
+              "@ | Out-File -FilePath "$wrapperDir\valkey-cli.bat" -Encoding ASCII
+                  Write-Host "Created valkey-cli.bat wrapper"
+              }
+              
+              # Check and create redis-cli.bat
+              if (wsl which redis-cli 2>$null) {
+                  @"
+              @echo off
+              wsl redis-cli %*
+              "@ | Out-File -FilePath "$wrapperDir\redis-cli.bat" -Encoding ASCII
+                  Write-Host "Created redis-cli.bat wrapper"
+              }
+              
+              # Add to PATH for subsequent steps
+              echo "$wrapperDir" >> $env:GITHUB_PATH
+              
+              # List created wrappers
+              Write-Host "Created wrapper scripts:"
+              Get-ChildItem "$wrapperDir\*.bat" | ForEach-Object { Write-Host "  $($_.Name)" }
+
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
           uses: ./.github/workflows/install-rust-and-protoc

From dad86bf069789fb3c7ae7d099c860c9fac0536b9 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 17:49:35 -0700
Subject: [PATCH 039/106] Change cluster_manager.py to use where on Windows in
 addition to which

- Depends on native Windows vs WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml      |  5 +----
 utils/cluster_manager.py                        | 17 ++++++++++++++++-
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 71b527163c..be4b0ab2c4 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -219,10 +219,7 @@ runs:
               
               # Add to PATH for subsequent steps
               echo "$wrapperDir" >> $env:GITHUB_PATH
-              
-              # List created wrappers
-              Write-Host "Created wrapper scripts:"
-              Get-ChildItem "$wrapperDir\*.bat" | ForEach-Object { Write-Host "  $($_.Name)" }
+              Write-Host "Added $wrapperDir to PATH"
 
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index e5ea7ec51a..aa8f7ecfdd 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -38,6 +38,7 @@
 
 def get_command(commands: List[str]) -> str:
     for command in commands:
+        # Try 'which' first (Unix/Linux/macOS)
         try:
             result = subprocess.run(
                 ["which", command],
@@ -48,7 +49,21 @@ def get_command(commands: List[str]) -> str:
             if result.returncode == 0:
                 return command
         except Exception as e:
-            logging.error(f"Error checking {command}: {e}")
+            logging.debug(f"'which' failed for {command}: {e}")
+        
+        # Fallback to 'where' (Windows)
+        try:
+            result = subprocess.run(
+                ["where", command],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            if result.returncode == 0:
+                return command
+        except Exception as e:
+            logging.debug(f"'where' failed for {command}: {e}")
+            
     raise Exception(f"Neither {' nor '.join(commands)} found in the system.")
 
 

From 747b7ad5dd4fb1a6fbb7a8ba464672470f31f8ab Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 18:20:12 -0700
Subject: [PATCH 040/106] Use the full path when invokign subprocess in
 cluster_manager.py

Needed to use the Win32 CreateProcess API under the hood

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../workflows/install-shared-dependencies/action.yml   | 10 +++++-----
 utils/cluster_manager.py                               |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index be4b0ab2c4..d909b6461f 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -180,7 +180,7 @@ runs:
               # Create wrapper batch files that call WSL binaries
               $wrapperDir = "C:\valkey-wrappers"
               New-Item -ItemType Directory -Force -Path $wrapperDir
-              
+
               # Check and create valkey-server.bat
               if (wsl which valkey-server 2>$null) {
                   @"
@@ -189,7 +189,7 @@ runs:
               "@ | Out-File -FilePath "$wrapperDir\valkey-server.bat" -Encoding ASCII
                   Write-Host "Created valkey-server.bat wrapper"
               }
-              
+
               # Check and create redis-server.bat
               if (wsl which redis-server 2>$null) {
                   @"
@@ -198,7 +198,7 @@ runs:
               "@ | Out-File -FilePath "$wrapperDir\redis-server.bat" -Encoding ASCII
                   Write-Host "Created redis-server.bat wrapper"
               }
-              
+
               # Check and create valkey-cli.bat
               if (wsl which valkey-cli 2>$null) {
                   @"
@@ -207,7 +207,7 @@ runs:
               "@ | Out-File -FilePath "$wrapperDir\valkey-cli.bat" -Encoding ASCII
                   Write-Host "Created valkey-cli.bat wrapper"
               }
-              
+
               # Check and create redis-cli.bat
               if (wsl which redis-cli 2>$null) {
                   @"
@@ -216,7 +216,7 @@ runs:
               "@ | Out-File -FilePath "$wrapperDir\redis-cli.bat" -Encoding ASCII
                   Write-Host "Created redis-cli.bat wrapper"
               }
-              
+
               # Add to PATH for subsequent steps
               echo "$wrapperDir" >> $env:GITHUB_PATH
               Write-Host "Added $wrapperDir to PATH"
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index aa8f7ecfdd..6e214915d1 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -47,7 +47,7 @@ def get_command(commands: List[str]) -> str:
                 text=True,
             )
             if result.returncode == 0:
-                return command
+                return result.stdout.strip()  # Return full path
         except Exception as e:
             logging.debug(f"'which' failed for {command}: {e}")
         
@@ -60,7 +60,7 @@ def get_command(commands: List[str]) -> str:
                 text=True,
             )
             if result.returncode == 0:
-                return command
+                return result.stdout.strip().split('\n')[0]  # Return first full path
         except Exception as e:
             logging.debug(f"'where' failed for {command}: {e}")
             

From ed6caaf4305a1d0fe8fdf6e6a5e964fe3b2441ab Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 19:15:22 -0700
Subject: [PATCH 041/106] Handle Windows specifics in gradle and
 cluster_manager.py

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle | 13 +++++++-----
 utils/cluster_manager.py    | 42 +++++++++++++++++++++++++++++++++++--
 2 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index cfe90bb156..3365e050bd 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -50,6 +50,9 @@ def standaloneHosts = ''
 def clusterHosts = ''
 def azClusterHosts = ''
 
+// Platform-specific Python executable
+def pythonExecutable = System.getProperty('os.name').toLowerCase().contains('windows') ? 'python' : 'python3'
+
 ext {
     extractAddressesFromClusterManagerOutput = { String output ->
         for (def line : output.split("\n")) {
@@ -64,7 +67,7 @@ ext {
 
 tasks.register('stopAllAfterTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine 'python3', 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder'
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder'
 }
 
 // We need to call for stop before and after the test, but gradle doesn't support executing a task
@@ -72,7 +75,7 @@ tasks.register('stopAllAfterTests', Exec) {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine 'python3', 'cluster_manager.py', 'stop', '--prefix', 'cluster'
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster'
     ignoreExitValue true // ignore fail if servers are stopped before
 }
 
@@ -87,7 +90,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '--cluster-mode']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode']
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -106,7 +109,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4']
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -127,7 +130,7 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = ['python3', 'cluster_manager.py', 'start', '-r', '0']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0']
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 6e214915d1..5b6364b5c5 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -6,6 +6,7 @@
 import json
 import logging
 import os
+import platform
 import random
 import re
 import signal
@@ -60,6 +61,9 @@ def get_command(commands: List[str]) -> str:
                 text=True,
             )
             if result.returncode == 0:
+                # Mark that we used 'where' to find the command (Windows wrapper scripts)
+                global _USING_WINDOWS_WRAPPERS
+                _USING_WINDOWS_WRAPPERS = True
                 return result.stdout.strip().split('\n')[0]  # Return first full path
         except Exception as e:
             logging.debug(f"'where' failed for {command}: {e}")
@@ -70,6 +74,7 @@ def get_command(commands: List[str]) -> str:
 # Global variables for caching server commands (set lazily)
 _SERVER_COMMAND = None
 _CLI_COMMAND = None
+_USING_WINDOWS_WRAPPERS = False
 
 
 def get_server_command() -> str:
@@ -357,6 +362,34 @@ def create_cluster_folder(path: str, prefix: str) -> str:
     return cluster_folder
 
 
+def windows_path_to_wsl(path: str) -> str:
+    """Convert Windows path to WSL path format when using Windows wrapper scripts.
+    
+    This should only be used when launching cluster_manager.py from a normal Windows 
+    shell to launch wrapper scripts that run WSL builds of servers (detected by 
+    using 'where' command to find server executables).
+    
+    Args:
+        path: Windows path (e.g., 'D:\\folder\\file')
+        
+    Returns:
+        WSL path (e.g., '/mnt/d/folder/file') if using Windows wrappers, otherwise original path
+    """
+    global _USING_WINDOWS_WRAPPERS
+    if not _USING_WINDOWS_WRAPPERS:
+        return path
+    
+    # Convert backslashes to forward slashes
+    wsl_path = path.replace('\\', '/')
+    
+    # Convert drive letter (e.g., 'D:' -> '/mnt/d')
+    if len(wsl_path) >= 2 and wsl_path[1] == ':':
+        drive_letter = wsl_path[0].lower()
+        wsl_path = f'/mnt/{drive_letter}{wsl_path[2:]}'
+    
+    return wsl_path
+
+
 def start_server(
     host: str,
     port: Optional[int],
@@ -391,6 +424,11 @@ def get_server_version(server_name):
 
     # Define command arguments
     logfile = f"{node_folder}/server.log"
+    
+    # Convert paths to WSL format if on Windows
+    wsl_node_folder = windows_path_to_wsl(node_folder)
+    wsl_logfile = windows_path_to_wsl(logfile)
+    
     cmd_args = [
         get_server_command(),
         f"{'--tls-port' if tls else '--port'}",
@@ -398,11 +436,11 @@ def get_server_version(server_name):
         "--cluster-enabled",
         f"{'yes' if cluster_mode else 'no'}",
         "--dir",
-        node_folder,
+        wsl_node_folder,
         "--daemonize",
         "yes",
         "--logfile",
-        logfile,
+        wsl_logfile,
         "--protected-mode",
         "no",
         "--appendonly",

From 0800c8be593fe913d945281bfb10601f8f24a56b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 19:46:39 -0700
Subject: [PATCH 042/106] Change gradle to make the host for integration tests
 customizable

Use this to use the WSL host

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml  |  2 ++
 java/integTest/build.gradle | 13 ++++++++-----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index d4b2f99da6..321f36d0d6 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -180,6 +180,7 @@ jobs:
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "VALKEY_INTEG_TEST_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
@@ -283,6 +284,7 @@ jobs:
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
+                  echo "VALKEY_INTEG_TEST_IP=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
                   echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
                   Write-Host "WSL IP address: $wslIp"
diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 3365e050bd..7a063f3ccc 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -53,6 +53,9 @@ def azClusterHosts = ''
 // Platform-specific Python executable
 def pythonExecutable = System.getProperty('os.name').toLowerCase().contains('windows') ? 'python' : 'python3'
 
+// Use integration test IP from environment variable if available, otherwise default to localhost
+def clusterHost = System.getenv('VALKEY_INTEG_TEST_IP') ?: '127.0.0.1'
+
 ext {
     extractAddressesFromClusterManagerOutput = { String output ->
         for (def line : output.split("\n")) {
@@ -67,7 +70,7 @@ ext {
 
 tasks.register('stopAllAfterTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder'
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '--host', clusterHost
 }
 
 // We need to call for stop before and after the test, but gradle doesn't support executing a task
@@ -75,7 +78,7 @@ tasks.register('stopAllAfterTests', Exec) {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster'
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--host', clusterHost
     ignoreExitValue true // ignore fail if servers are stopped before
 }
 
@@ -90,7 +93,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -109,7 +112,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -130,7 +133,7 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0']
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os

From 68849afd796dd82732b4e360eda4a73bef2b53b4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 19:57:39 -0700
Subject: [PATCH 043/106] Change cluster integration tests to not hardcode
 python3

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../src/test/java/glide/cluster/ValkeyCluster.java     | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index e0e3d7534c..fccd08fafa 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -20,6 +20,12 @@ public class ValkeyCluster implements AutoCloseable {
                     .resolve("utils")
                     .resolve("cluster_manager.py");
 
+    /** Get platform-specific Python executable */
+    private static String getPythonExecutable() {
+        String osName = System.getProperty("os.name").toLowerCase();
+        return osName.contains("windows") ? "python" : "python3";
+    }
+
     private boolean tls = false;
     private String clusterFolder;
     private List<NodeAddress> nodesAddr;
@@ -48,7 +54,7 @@ public ValkeyCluster(
         } else {
             this.tls = tls;
             List<String> command = new ArrayList<>();
-            command.add("python3");
+            command.add(getPythonExecutable());
             command.add(SCRIPT_FILE.toString());
 
             if (tls) {
@@ -173,7 +179,7 @@ public String getClusterFolder() {
     public void close() throws IOException {
         if (clusterFolder != null && !clusterFolder.isEmpty()) {
             List<String> command = new ArrayList<>();
-            command.add("python3");
+            command.add(getPythonExecutable());
             command.add(SCRIPT_FILE.toString());
 
             if (tls) {

From 747283a0c1047da13d119950fc473cf27aa75523 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 20:14:13 -0700
Subject: [PATCH 044/106] Fix host parameterization for integration tests

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle                     | 10 +++++-----
 .../test/java/glide/cluster/ValkeyCluster.java  | 17 +++++++++++++++++
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 7a063f3ccc..b76420098a 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -70,7 +70,7 @@ ext {
 
 tasks.register('stopAllAfterTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '--host', clusterHost
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '-H', clusterHost
 }
 
 // We need to call for stop before and after the test, but gradle doesn't support executing a task
@@ -78,7 +78,7 @@ tasks.register('stopAllAfterTests', Exec) {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--host', clusterHost
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '-H', clusterHost
     ignoreExitValue true // ignore fail if servers are stopped before
 }
 
@@ -93,7 +93,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-H', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -112,7 +112,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '-H', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -133,7 +133,7 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '--host', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '-H', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index fccd08fafa..b2eae56c62 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -63,6 +63,14 @@ public ValkeyCluster(
 
             command.add("start");
 
+            // Add host parameter - use environment variable or default to localhost
+            String host = System.getenv("VALKEY_INTEG_TEST_IP");
+            if (host == null || host.isEmpty()) {
+                host = "127.0.0.1";
+            }
+            command.add("-H");
+            command.add(host);
+
             if (clusterMode) {
                 command.add("--cluster-mode");
             }
@@ -187,6 +195,15 @@ public void close() throws IOException {
             }
 
             command.add("stop");
+            
+            // Add host parameter - use environment variable or default to localhost
+            String host = System.getenv("VALKEY_INTEG_TEST_IP");
+            if (host == null || host.isEmpty()) {
+                host = "127.0.0.1";
+            }
+            command.add("-H");
+            command.add(host);
+            
             command.add("--cluster-folder");
             command.add(clusterFolder);
 

From da625ce959cd603ad469711fe6fa5f619195d722 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 20:27:06 -0700
Subject: [PATCH 045/106] Fix bug in cluster_manager.py where the host
 parameter was unsupported

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle                   | 10 +++----
 .../java/glide/cluster/ValkeyCluster.java     |  4 +--
 utils/cluster_manager.py                      | 27 ++++++++++++-------
 3 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index b76420098a..7a063f3ccc 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -70,7 +70,7 @@ ext {
 
 tasks.register('stopAllAfterTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '-H', clusterHost
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '--host', clusterHost
 }
 
 // We need to call for stop before and after the test, but gradle doesn't support executing a task
@@ -78,7 +78,7 @@ tasks.register('stopAllAfterTests', Exec) {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '-H', clusterHost
+    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--host', clusterHost
     ignoreExitValue true // ignore fail if servers are stopped before
 }
 
@@ -93,7 +93,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-H', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -112,7 +112,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '-H', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -133,7 +133,7 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '-H', clusterHost]
+                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index b2eae56c62..793df5bee8 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -68,7 +68,7 @@ public ValkeyCluster(
             if (host == null || host.isEmpty()) {
                 host = "127.0.0.1";
             }
-            command.add("-H");
+            command.add("--host");
             command.add(host);
 
             if (clusterMode) {
@@ -201,7 +201,7 @@ public void close() throws IOException {
             if (host == null || host.isEmpty()) {
                 host = "127.0.0.1";
             }
-            command.add("-H");
+            command.add("--host");
             command.add(host);
             
             command.add("--cluster-folder");
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 5b6364b5c5..0e55b2aa5f 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -1083,15 +1083,6 @@ def stop_cluster(
 
 def main():
     parser = argparse.ArgumentParser(description="Cluster manager tool")
-    parser.add_argument(
-        "-H",
-        "--host",
-        type=str,
-        help="Host address (default: %(default)s)",
-        required=False,
-        default="127.0.0.1",
-    )
-
     parser.add_argument(
         "--tls",
         default=False,
@@ -1186,6 +1177,15 @@ def main():
         required=False,
     )
 
+    parser_start.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        help="Host address (default: %(default)s)",
+        required=False,
+        default="127.0.0.1",
+    )
+
     # Stop parser
     parser_stop = subparsers.add_parser("stop", help="Shutdown a running cluster")
     parser_stop.add_argument(
@@ -1225,6 +1225,15 @@ def main():
         default="",
     )
 
+    parser_stop.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        help="Host address (default: %(default)s)",
+        required=False,
+        default="127.0.0.1",
+    )
+
     args = parser.parse_args()
     # Check logging level
 

From 1cffd12cd5a4312aa23e754b77442012442081e9 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 21 Oct 2025 21:25:37 -0700
Subject: [PATCH 046/106] Normalize log file path

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 58 +++++++++++++++++++++++++++++-----------
 1 file changed, 43 insertions(+), 15 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 0e55b2aa5f..7bc6f29c10 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -362,32 +362,56 @@ def create_cluster_folder(path: str, prefix: str) -> str:
     return cluster_folder
 
 
-def windows_path_to_wsl(path: str) -> str:
-    """Convert Windows path to WSL path format when using Windows wrapper scripts.
+def normalize_path_for_server(path: str) -> str:
+    """Normalize path for server when using wrapper scripts.
     
     This should only be used when launching cluster_manager.py from a normal Windows 
     shell to launch wrapper scripts that run WSL builds of servers (detected by 
     using 'where' command to find server executables).
     
     Args:
-        path: Windows path (e.g., 'D:\\folder\\file')
+        path: Original path (e.g., 'D:\\folder\\file')
         
     Returns:
-        WSL path (e.g., '/mnt/d/folder/file') if using Windows wrappers, otherwise original path
+        Normalized path (e.g., '/mnt/d/folder/file') if using wrapper scripts, otherwise original path
     """
     global _USING_WINDOWS_WRAPPERS
     if not _USING_WINDOWS_WRAPPERS:
         return path
     
     # Convert backslashes to forward slashes
-    wsl_path = path.replace('\\', '/')
+    normalized_path = path.replace('\\', '/')
     
     # Convert drive letter (e.g., 'D:' -> '/mnt/d')
-    if len(wsl_path) >= 2 and wsl_path[1] == ':':
-        drive_letter = wsl_path[0].lower()
-        wsl_path = f'/mnt/{drive_letter}{wsl_path[2:]}'
+    if len(normalized_path) >= 2 and normalized_path[1] == ':':
+        drive_letter = normalized_path[0].lower()
+        normalized_path = f'/mnt/{drive_letter}{normalized_path[2:]}'
     
-    return wsl_path
+    return normalized_path
+
+
+def normalize_path_for_client(server_path: str) -> str:
+    """Normalize server path back to client-readable format when using wrapper scripts.
+    
+    Args:
+        server_path: Server path (e.g., '/mnt/d/folder/file')
+        
+    Returns:
+        Client-readable path (e.g., 'D:\\folder\\file') if using wrapper scripts, otherwise original path
+    """
+    global _USING_WINDOWS_WRAPPERS
+    if not _USING_WINDOWS_WRAPPERS:
+        return server_path
+    
+    # Convert WSL mount path back to Windows drive letter
+    if server_path.startswith('/mnt/') and len(server_path) > 5:
+        drive_letter = server_path[5].upper()
+        client_path = f'{drive_letter}:{server_path[6:]}'
+        # Convert forward slashes to backslashes
+        client_path = client_path.replace('/', '\\')
+        return client_path
+    
+    return server_path
 
 
 def start_server(
@@ -425,9 +449,9 @@ def get_server_version(server_name):
     # Define command arguments
     logfile = f"{node_folder}/server.log"
     
-    # Convert paths to WSL format if on Windows
-    wsl_node_folder = windows_path_to_wsl(node_folder)
-    wsl_logfile = windows_path_to_wsl(logfile)
+    # Convert paths to server format if using wrapper scripts
+    server_node_folder = normalize_path_for_server(node_folder)
+    server_logfile = normalize_path_for_server(logfile)
     
     cmd_args = [
         get_server_command(),
@@ -436,11 +460,11 @@ def get_server_version(server_name):
         "--cluster-enabled",
         f"{'yes' if cluster_mode else 'no'}",
         "--dir",
-        wsl_node_folder,
+        server_node_folder,
         "--daemonize",
         "yes",
         "--logfile",
-        wsl_logfile,
+        server_logfile,
         "--protected-mode",
         "no",
         "--appendonly",
@@ -537,7 +561,11 @@ def create_servers(
     while len(servers_to_check) > 0:
         server, node_folder = servers_to_check.pop()
         logging.debug(f"Checking server {server.host}:{server.port}")
-        if is_address_already_in_use(server, f"{node_folder}/server.log"):
+        # Convert log file path: server format for server, client format for Python to read
+        log_file_path = f"{node_folder}/server.log"
+        server_log_file_path = normalize_path_for_server(log_file_path)
+        readable_log_file_path = normalize_path_for_client(server_log_file_path)
+        if is_address_already_in_use(server, readable_log_file_path):
             remove_folder(node_folder)
             if ports is not None:
                 # The user passed a taken port, exit with an error

From 290db73a47f07eec73ac23a8221982ad6f79af7e Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 04:56:26 -0700
Subject: [PATCH 047/106] spotless

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/cluster/ValkeyCluster.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 793df5bee8..a39d9c532a 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -195,7 +195,7 @@ public void close() throws IOException {
             }
 
             command.add("stop");
-            
+
             // Add host parameter - use environment variable or default to localhost
             String host = System.getenv("VALKEY_INTEG_TEST_IP");
             if (host == null || host.isEmpty()) {
@@ -203,7 +203,7 @@ public void close() throws IOException {
             }
             command.add("--host");
             command.add(host);
-            
+
             command.add("--cluster-folder");
             command.add(clusterFolder);
 

From 4de0f3866fa71fbb0e097ecb0df102dda587a8a4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 04:56:41 -0700
Subject: [PATCH 048/106] Normalize paths in wait_for_message

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 7bc6f29c10..e568dc7282 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -694,10 +694,12 @@ def wait_for_a_message_in_logs(
         if not dir.is_dir():
             continue
         log_file = f"{dir}/server.log"
+        # Normalize log file path for client reading when using wrapper scripts
+        readable_log_file = normalize_path_for_client(normalize_path_for_server(log_file))
 
         if server_ports and os.path.basename(os.path.normpath(dir)) not in server_ports:
             continue
-        if not wait_for_message(log_file, message, 10):
+        if not wait_for_message(readable_log_file, message, 10):
             raise Exception(
                 f"During the timeout duration, the server logs associated with port {dir} did not contain the message:{message}."
                 f"See {dir}/server.log for more information"

From aefb8048b19320af3685f41386dec619e91a32a5 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 06:01:12 -0700
Subject: [PATCH 049/106] Call cluster_manager.py using wsl

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 50 +----------
 java/integTest/build.gradle                   | 15 ++--
 .../java/glide/cluster/ValkeyCluster.java     | 15 ++--
 utils/cluster_manager.py                      | 83 +------------------
 4 files changed, 21 insertions(+), 142 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index d909b6461f..b96e21cdcc 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -89,7 +89,7 @@ runs:
               distribution: Ubuntu-22.04
               use-cache: true
               update: true
-              additional-packages: build-essential git pkg-config libssl-dev
+              additional-packages: build-essential git pkg-config libssl-dev python3 python3-pip
 
         - name: Cache Valkey build
           if: "${{ inputs.engine-version }}"
@@ -173,54 +173,6 @@ runs:
                   hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
               fi
 
-        - name: Create WSL wrapper scripts for Valkey binaries (Windows)
-          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
-          shell: pwsh
-          run: |
-              # Create wrapper batch files that call WSL binaries
-              $wrapperDir = "C:\valkey-wrappers"
-              New-Item -ItemType Directory -Force -Path $wrapperDir
-
-              # Check and create valkey-server.bat
-              if (wsl which valkey-server 2>$null) {
-                  @"
-              @echo off
-              wsl valkey-server %*
-              "@ | Out-File -FilePath "$wrapperDir\valkey-server.bat" -Encoding ASCII
-                  Write-Host "Created valkey-server.bat wrapper"
-              }
-
-              # Check and create redis-server.bat
-              if (wsl which redis-server 2>$null) {
-                  @"
-              @echo off
-              wsl redis-server %*
-              "@ | Out-File -FilePath "$wrapperDir\redis-server.bat" -Encoding ASCII
-                  Write-Host "Created redis-server.bat wrapper"
-              }
-
-              # Check and create valkey-cli.bat
-              if (wsl which valkey-cli 2>$null) {
-                  @"
-              @echo off
-              wsl valkey-cli %*
-              "@ | Out-File -FilePath "$wrapperDir\valkey-cli.bat" -Encoding ASCII
-                  Write-Host "Created valkey-cli.bat wrapper"
-              }
-
-              # Check and create redis-cli.bat
-              if (wsl which redis-cli 2>$null) {
-                  @"
-              @echo off
-              wsl redis-cli %*
-              "@ | Out-File -FilePath "$wrapperDir\redis-cli.bat" -Encoding ASCII
-                  Write-Host "Created redis-cli.bat wrapper"
-              }
-
-              # Add to PATH for subsequent steps
-              echo "$wrapperDir" >> $env:GITHUB_PATH
-              Write-Host "Added $wrapperDir to PATH"
-
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
           uses: ./.github/workflows/install-rust-and-protoc
diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 7a063f3ccc..7202b895b7 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -50,8 +50,9 @@ def standaloneHosts = ''
 def clusterHosts = ''
 def azClusterHosts = ''
 
-// Platform-specific Python executable
-def pythonExecutable = System.getProperty('os.name').toLowerCase().contains('windows') ? 'python' : 'python3'
+// Platform-specific Python executable and WSL handling
+def isWindows = System.getProperty('os.name').toLowerCase().contains('windows')
+def pythonCmd = isWindows ? ['wsl', '--', 'python3'] : ['python3']
 
 // Use integration test IP from environment variable if available, otherwise default to localhost
 def clusterHost = System.getenv('VALKEY_INTEG_TEST_IP') ?: '127.0.0.1'
@@ -70,7 +71,7 @@ ext {
 
 tasks.register('stopAllAfterTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '--host', clusterHost
+    commandLine(*pythonCmd, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--keep-folder', '--host', clusterHost)
 }
 
 // We need to call for stop before and after the test, but gradle doesn't support executing a task
@@ -78,7 +79,7 @@ tasks.register('stopAllAfterTests', Exec) {
 // We need to call for stop in case if previous test run was interrupted/crashed and didn't stop.
 tasks.register('stopAllBeforeTests', Exec) {
     workingDir "${project.rootDir}/../utils"
-    commandLine pythonExecutable, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--host', clusterHost
+    commandLine(*pythonCmd, 'cluster_manager.py', 'stop', '--prefix', 'cluster', '--host', clusterHost)
     ignoreExitValue true // ignore fail if servers are stopped before
 }
 
@@ -93,7 +94,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -112,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -133,7 +134,7 @@ tasks.register('startStandalone') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [pythonExecutable, 'cluster_manager.py', 'start', '-r', '0', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '-r', '0', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index a39d9c532a..16f7a53dab 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -8,6 +8,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
@@ -20,10 +21,14 @@ public class ValkeyCluster implements AutoCloseable {
                     .resolve("utils")
                     .resolve("cluster_manager.py");
 
-    /** Get platform-specific Python executable */
-    private static String getPythonExecutable() {
+    /** Get platform-specific Python command with WSL support */
+    private static List<String> getPythonCommand() {
         String osName = System.getProperty("os.name").toLowerCase();
-        return osName.contains("windows") ? "python" : "python3";
+        if (osName.contains("windows")) {
+            return Arrays.asList("wsl", "--", "python3");
+        } else {
+            return Arrays.asList("python3");
+        }
     }
 
     private boolean tls = false;
@@ -54,7 +59,7 @@ public ValkeyCluster(
         } else {
             this.tls = tls;
             List<String> command = new ArrayList<>();
-            command.add(getPythonExecutable());
+            command.addAll(getPythonCommand());
             command.add(SCRIPT_FILE.toString());
 
             if (tls) {
@@ -187,7 +192,7 @@ public String getClusterFolder() {
     public void close() throws IOException {
         if (clusterFolder != null && !clusterFolder.isEmpty()) {
             List<String> command = new ArrayList<>();
-            command.add(getPythonExecutable());
+            command.addAll(getPythonCommand());
             command.add(SCRIPT_FILE.toString());
 
             if (tls) {
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index e568dc7282..15c15ce4f8 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -39,34 +39,8 @@
 
 def get_command(commands: List[str]) -> str:
     for command in commands:
-        # Try 'which' first (Unix/Linux/macOS)
-        try:
-            result = subprocess.run(
-                ["which", command],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            if result.returncode == 0:
-                return result.stdout.strip()  # Return full path
-        except Exception as e:
-            logging.debug(f"'which' failed for {command}: {e}")
-        
-        # Fallback to 'where' (Windows)
-        try:
-            result = subprocess.run(
-                ["where", command],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            if result.returncode == 0:
-                # Mark that we used 'where' to find the command (Windows wrapper scripts)
-                global _USING_WINDOWS_WRAPPERS
-                _USING_WINDOWS_WRAPPERS = True
-                return result.stdout.strip().split('\n')[0]  # Return first full path
-        except Exception as e:
-            logging.debug(f"'where' failed for {command}: {e}")
+        if shutil.which(command):
+            return command
             
     raise Exception(f"Neither {' nor '.join(commands)} found in the system.")
 
@@ -74,7 +48,6 @@ def get_command(commands: List[str]) -> str:
 # Global variables for caching server commands (set lazily)
 _SERVER_COMMAND = None
 _CLI_COMMAND = None
-_USING_WINDOWS_WRAPPERS = False
 
 
 def get_server_command() -> str:
@@ -362,58 +335,6 @@ def create_cluster_folder(path: str, prefix: str) -> str:
     return cluster_folder
 
 
-def normalize_path_for_server(path: str) -> str:
-    """Normalize path for server when using wrapper scripts.
-    
-    This should only be used when launching cluster_manager.py from a normal Windows 
-    shell to launch wrapper scripts that run WSL builds of servers (detected by 
-    using 'where' command to find server executables).
-    
-    Args:
-        path: Original path (e.g., 'D:\\folder\\file')
-        
-    Returns:
-        Normalized path (e.g., '/mnt/d/folder/file') if using wrapper scripts, otherwise original path
-    """
-    global _USING_WINDOWS_WRAPPERS
-    if not _USING_WINDOWS_WRAPPERS:
-        return path
-    
-    # Convert backslashes to forward slashes
-    normalized_path = path.replace('\\', '/')
-    
-    # Convert drive letter (e.g., 'D:' -> '/mnt/d')
-    if len(normalized_path) >= 2 and normalized_path[1] == ':':
-        drive_letter = normalized_path[0].lower()
-        normalized_path = f'/mnt/{drive_letter}{normalized_path[2:]}'
-    
-    return normalized_path
-
-
-def normalize_path_for_client(server_path: str) -> str:
-    """Normalize server path back to client-readable format when using wrapper scripts.
-    
-    Args:
-        server_path: Server path (e.g., '/mnt/d/folder/file')
-        
-    Returns:
-        Client-readable path (e.g., 'D:\\folder\\file') if using wrapper scripts, otherwise original path
-    """
-    global _USING_WINDOWS_WRAPPERS
-    if not _USING_WINDOWS_WRAPPERS:
-        return server_path
-    
-    # Convert WSL mount path back to Windows drive letter
-    if server_path.startswith('/mnt/') and len(server_path) > 5:
-        drive_letter = server_path[5].upper()
-        client_path = f'{drive_letter}:{server_path[6:]}'
-        # Convert forward slashes to backslashes
-        client_path = client_path.replace('/', '\\')
-        return client_path
-    
-    return server_path
-
-
 def start_server(
     host: str,
     port: Optional[int],

From ddd737d0d2f805480b94a4d69a66664bfbc1e935 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 06:12:48 -0700
Subject: [PATCH 050/106] Remove normalization

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 15c15ce4f8..1db7dfb4c5 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -9,6 +9,7 @@
 import platform
 import random
 import re
+import shutil
 import signal
 import socket
 import string
@@ -370,10 +371,6 @@ def get_server_version(server_name):
     # Define command arguments
     logfile = f"{node_folder}/server.log"
     
-    # Convert paths to server format if using wrapper scripts
-    server_node_folder = normalize_path_for_server(node_folder)
-    server_logfile = normalize_path_for_server(logfile)
-    
     cmd_args = [
         get_server_command(),
         f"{'--tls-port' if tls else '--port'}",
@@ -381,11 +378,11 @@ def get_server_version(server_name):
         "--cluster-enabled",
         f"{'yes' if cluster_mode else 'no'}",
         "--dir",
-        server_node_folder,
+        node_folder,
         "--daemonize",
         "yes",
         "--logfile",
-        server_logfile,
+        logfile,
         "--protected-mode",
         "no",
         "--appendonly",
@@ -482,11 +479,7 @@ def create_servers(
     while len(servers_to_check) > 0:
         server, node_folder = servers_to_check.pop()
         logging.debug(f"Checking server {server.host}:{server.port}")
-        # Convert log file path: server format for server, client format for Python to read
-        log_file_path = f"{node_folder}/server.log"
-        server_log_file_path = normalize_path_for_server(log_file_path)
-        readable_log_file_path = normalize_path_for_client(server_log_file_path)
-        if is_address_already_in_use(server, readable_log_file_path):
+        if is_address_already_in_use(server, f"{node_folder}/server.log"):
             remove_folder(node_folder)
             if ports is not None:
                 # The user passed a taken port, exit with an error
@@ -615,12 +608,10 @@ def wait_for_a_message_in_logs(
         if not dir.is_dir():
             continue
         log_file = f"{dir}/server.log"
-        # Normalize log file path for client reading when using wrapper scripts
-        readable_log_file = normalize_path_for_client(normalize_path_for_server(log_file))
 
         if server_ports and os.path.basename(os.path.normpath(dir)) not in server_ports:
             continue
-        if not wait_for_message(readable_log_file, message, 10):
+        if not wait_for_message(log_file, message, 10):
             raise Exception(
                 f"During the timeout duration, the server logs associated with port {dir} did not contain the message:{message}."
                 f"See {dir}/server.log for more information"

From fb009965c60749cb880f273950286ed0d5f5d955 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 08:43:55 -0700
Subject: [PATCH 051/106] Increase the timeout for cluster initialization

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 1db7dfb4c5..fedef48cd4 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -689,7 +689,7 @@ def wait_for_all_topology_views(
             "slots",
         ]
         logging.debug(f"Executing: {cmd_args}")
-        retries = 80
+        retries = 160
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
             if output is not None and output.count(f"{server.host}") == len(servers):

From d8bdc72455ce2d730f91e7c6bd6d83c5613436b1 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 09:19:59 -0700
Subject: [PATCH 052/106] Debugging cluster_manager.py issues on WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index fedef48cd4..328677d4f4 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -64,6 +64,7 @@ def get_cli_command() -> str:
     global _CLI_COMMAND
     if _CLI_COMMAND is None:
         _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
+        logging.debug(f"Using CLI command: {_CLI_COMMAND}")
     return _CLI_COMMAND
 
 
@@ -654,6 +655,7 @@ def parse_cluster_nodes(command_output: Optional[str]) -> Optional[dict]:
 
 def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
     try:
+        logging.debug(f"Executing CLI command: {' '.join(cmd_args)}")
         p = subprocess.Popen(
             cmd_args,
             stdout=subprocess.PIPE,
@@ -661,12 +663,15 @@ def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
             text=True,
         )
         output, err = p.communicate(timeout=5)
+        logging.debug(f"CLI output: {output}")
+        logging.debug(f"CLI stderr: {err}")
         if err:
             raise Exception(
                 f"Failed to execute command: {str(p.args)}\n Return code: {p.returncode}\n Error: {err}"
             )
         return output
     except subprocess.TimeoutExpired:
+        logging.debug("CLI command timed out")
         return None
 
 
@@ -692,7 +697,11 @@ def wait_for_all_topology_views(
         retries = 160
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
-            if output is not None and output.count(f"{server.host}") == len(servers):
+            logging.debug(f"Checking server {server.host}:{server.port}, output: {output}")
+            if output is not None:
+                host_count = output.count(f"{server.host}")
+                logging.debug(f"Found {host_count} occurrences of '{server.host}' in output, need {len(servers)}")
+                if host_count == len(servers):
                 # Server is ready, get the node's role
                 cmd_args = [
                     get_cli_command(),

From ba1e9d2c2802178d1388cbbe55230e89bd493e47 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 09:38:32 -0700
Subject: [PATCH 053/106] Fix python syntax error

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 328677d4f4..c6f8b8176f 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -702,7 +702,7 @@ def wait_for_all_topology_views(
                 host_count = output.count(f"{server.host}")
                 logging.debug(f"Found {host_count} occurrences of '{server.host}' in output, need {len(servers)}")
                 if host_count == len(servers):
-                # Server is ready, get the node's role
+                    # Server is ready, get the node's role
                 cmd_args = [
                     get_cli_command(),
                     "-h",

From 21d10bbf3f9b1920da7a8e746ecebe2f581f63a4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 10:03:50 -0700
Subject: [PATCH 054/106] Python indentation fix

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index c6f8b8176f..14bf87516c 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -703,22 +703,22 @@ def wait_for_all_topology_views(
                 logging.debug(f"Found {host_count} occurrences of '{server.host}' in output, need {len(servers)}")
                 if host_count == len(servers):
                     # Server is ready, get the node's role
-                cmd_args = [
-                    get_cli_command(),
-                    "-h",
-                    server.host,
-                    "-p",
-                    str(server.port),
-                    *get_cli_option_args(cluster_folder, use_tls),
-                    "cluster",
-                    "nodes",
-                ]
-                cluster_slots_output = redis_cli_run_command(cmd_args)
-                node_info = parse_cluster_nodes(cluster_slots_output)
-                if node_info:
-                    server.set_primary(node_info["is_primary"])
-                logging.debug(f"Server {server} is ready!")
-                break
+                    cmd_args = [
+                        get_cli_command(),
+                        "-h",
+                        server.host,
+                        "-p",
+                        str(server.port),
+                        *get_cli_option_args(cluster_folder, use_tls),
+                        "cluster",
+                        "nodes",
+                    ]
+                    cluster_slots_output = redis_cli_run_command(cmd_args)
+                    node_info = parse_cluster_nodes(cluster_slots_output)
+                    if node_info:
+                        server.set_primary(node_info["is_primary"])
+                    logging.debug(f"Server {server} is ready!")
+                    break
             else:
                 retries -= 1
                 time.sleep(1)

From dc34dd9430d8b297dac356fe117033c7fcfe8876 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 11:02:45 -0700
Subject: [PATCH 055/106] Speed up cluster_manager debugging

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 45 ++++++++++++++++------------------------
 1 file changed, 18 insertions(+), 27 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 14bf87516c..fedef48cd4 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -64,7 +64,6 @@ def get_cli_command() -> str:
     global _CLI_COMMAND
     if _CLI_COMMAND is None:
         _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
-        logging.debug(f"Using CLI command: {_CLI_COMMAND}")
     return _CLI_COMMAND
 
 
@@ -655,7 +654,6 @@ def parse_cluster_nodes(command_output: Optional[str]) -> Optional[dict]:
 
 def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
     try:
-        logging.debug(f"Executing CLI command: {' '.join(cmd_args)}")
         p = subprocess.Popen(
             cmd_args,
             stdout=subprocess.PIPE,
@@ -663,15 +661,12 @@ def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
             text=True,
         )
         output, err = p.communicate(timeout=5)
-        logging.debug(f"CLI output: {output}")
-        logging.debug(f"CLI stderr: {err}")
         if err:
             raise Exception(
                 f"Failed to execute command: {str(p.args)}\n Return code: {p.returncode}\n Error: {err}"
             )
         return output
     except subprocess.TimeoutExpired:
-        logging.debug("CLI command timed out")
         return None
 
 
@@ -697,28 +692,24 @@ def wait_for_all_topology_views(
         retries = 160
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
-            logging.debug(f"Checking server {server.host}:{server.port}, output: {output}")
-            if output is not None:
-                host_count = output.count(f"{server.host}")
-                logging.debug(f"Found {host_count} occurrences of '{server.host}' in output, need {len(servers)}")
-                if host_count == len(servers):
-                    # Server is ready, get the node's role
-                    cmd_args = [
-                        get_cli_command(),
-                        "-h",
-                        server.host,
-                        "-p",
-                        str(server.port),
-                        *get_cli_option_args(cluster_folder, use_tls),
-                        "cluster",
-                        "nodes",
-                    ]
-                    cluster_slots_output = redis_cli_run_command(cmd_args)
-                    node_info = parse_cluster_nodes(cluster_slots_output)
-                    if node_info:
-                        server.set_primary(node_info["is_primary"])
-                    logging.debug(f"Server {server} is ready!")
-                    break
+            if output is not None and output.count(f"{server.host}") == len(servers):
+                # Server is ready, get the node's role
+                cmd_args = [
+                    get_cli_command(),
+                    "-h",
+                    server.host,
+                    "-p",
+                    str(server.port),
+                    *get_cli_option_args(cluster_folder, use_tls),
+                    "cluster",
+                    "nodes",
+                ]
+                cluster_slots_output = redis_cli_run_command(cmd_args)
+                node_info = parse_cluster_nodes(cluster_slots_output)
+                if node_info:
+                    server.set_primary(node_info["is_primary"])
+                logging.debug(f"Server {server} is ready!")
+                break
             else:
                 retries -= 1
                 time.sleep(1)

From 20fdeeadc39f82ca2189ab9e42f57e8dffb96c1a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 12:07:09 -0700
Subject: [PATCH 056/106] More logging info

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index fedef48cd4..3d1d3ccf64 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -662,11 +662,13 @@ def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
         )
         output, err = p.communicate(timeout=5)
         if err:
+            logging.error(f"CLI command failed: {' '.join(cmd_args[:3])}... - Error: {err}")
             raise Exception(
                 f"Failed to execute command: {str(p.args)}\n Return code: {p.returncode}\n Error: {err}"
             )
         return output
     except subprocess.TimeoutExpired:
+        logging.error(f"CLI command timed out: {' '.join(cmd_args[:3])}...")
         return None
 
 
@@ -692,7 +694,10 @@ def wait_for_all_topology_views(
         retries = 160
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
-            if output is not None and output.count(f"{server.host}") == len(servers):
+            if output is not None:
+                host_count = output.count(f"{server.host}")
+                if host_count == len(servers):
+                    # Server is ready, get the node's role
                 # Server is ready, get the node's role
                 cmd_args = [
                     get_cli_command(),
@@ -710,8 +715,16 @@ def wait_for_all_topology_views(
                     server.set_primary(node_info["is_primary"])
                 logging.debug(f"Server {server} is ready!")
                 break
+                else:
+                    if retries % 40 == 0:  # Log every 40 retries to avoid spam
+                        logging.info(f"Waiting for {server.host}:{server.port} - found {host_count}/{len(servers)} nodes")
+                    retries -= 1
+                    time.sleep(1)
+                    continue
             else:
                 retries -= 1
+                if retries == 0:
+                    logging.error(f"Topology wait failed for {server.host}:{server.port} - no CLI output received")
                 time.sleep(1)
                 continue
 

From 52fa8af6f44bd4251a0ba0187d14b91840f6e460 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 13:37:13 -0700
Subject: [PATCH 057/106] Fix linter issues

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 3d1d3ccf64..bff12cdd9f 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -698,23 +698,22 @@ def wait_for_all_topology_views(
                 host_count = output.count(f"{server.host}")
                 if host_count == len(servers):
                     # Server is ready, get the node's role
-                # Server is ready, get the node's role
-                cmd_args = [
-                    get_cli_command(),
-                    "-h",
-                    server.host,
-                    "-p",
-                    str(server.port),
-                    *get_cli_option_args(cluster_folder, use_tls),
-                    "cluster",
-                    "nodes",
-                ]
-                cluster_slots_output = redis_cli_run_command(cmd_args)
-                node_info = parse_cluster_nodes(cluster_slots_output)
-                if node_info:
-                    server.set_primary(node_info["is_primary"])
-                logging.debug(f"Server {server} is ready!")
-                break
+                    cmd_args = [
+                        get_cli_command(),
+                        "-h",
+                        server.host,
+                        "-p",
+                        str(server.port),
+                        *get_cli_option_args(cluster_folder, use_tls),
+                        "cluster",
+                        "nodes",
+                    ]
+                    cluster_slots_output = redis_cli_run_command(cmd_args)
+                    node_info = parse_cluster_nodes(cluster_slots_output)
+                    if node_info:
+                        server.set_primary(node_info["is_primary"])
+                    logging.debug(f"Server {server} is ready!")
+                    break
                 else:
                     if retries % 40 == 0:  # Log every 40 retries to avoid spam
                         logging.info(f"Waiting for {server.host}:{server.port} - found {host_count}/{len(servers)} nodes")

From abfca0cbca7d94e676a15841d52f116960dad0b2 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 14:19:12 -0700
Subject: [PATCH 058/106] Bind to 0.0.0.0 for cluster communication to work in
 containerized environments

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../src/test/java/glide/cluster/ValkeyCluster.java     | 10 +++++-----
 utils/cluster_manager.py                               |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 16f7a53dab..1c7bb88517 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -66,6 +66,11 @@ public ValkeyCluster(
                 command.add("--tls");
             }
 
+            command.add("-n");
+            command.add(String.valueOf(shardCount));
+            command.add("-r");
+            command.add(String.valueOf(replicaCount));
+
             command.add("start");
 
             // Add host parameter - use environment variable or default to localhost
@@ -87,11 +92,6 @@ public ValkeyCluster(
                 }
             }
 
-            command.add("-n");
-            command.add(String.valueOf(shardCount));
-            command.add("-r");
-            command.add(String.valueOf(replicaCount));
-
             ProcessBuilder pb = new ProcessBuilder(command);
             pb.redirectErrorStream(true);
             Process process = pb.start();
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index bff12cdd9f..15ec94d6b7 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -459,7 +459,7 @@ def create_servers(
             "--tls-auth-clients",  # Make it so client doesn't have to send cert
             "no",
             "--bind",
-            host,
+            "0.0.0.0",  # Bind to all interfaces so both WSL IP and localhost work
             "--port",
             "0",
         ]

From 79a6d58ac831bf891fa3f148b00332518b5c8af9 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 22 Oct 2025 16:23:14 -0700
Subject: [PATCH 059/106] Try turning off replication

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle                                   | 4 ++--
 java/integTest/src/test/java/glide/cluster/ValkeyCluster.java | 2 +-
 utils/cluster_manager.py                                      | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 7202b895b7..d44a7f2592 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -94,7 +94,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '0', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -113,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '0', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 1c7bb88517..1c93e1b995 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -120,7 +120,7 @@ public ValkeyCluster(
 
     /** Constructor with default values */
     public ValkeyCluster(boolean tls) throws IOException, InterruptedException {
-        this(tls, false, 3, 1, null, null);
+        this(tls, false, 3, 0, null, null);
     }
 
     private void parseClusterScriptStartOutput(String output) {
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 15ec94d6b7..7b33eb1320 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -459,7 +459,7 @@ def create_servers(
             "--tls-auth-clients",  # Make it so client doesn't have to send cert
             "no",
             "--bind",
-            "0.0.0.0",  # Bind to all interfaces so both WSL IP and localhost work
+            host,  # Bind to WSL IP for external access
             "--port",
             "0",
         ]
@@ -467,6 +467,7 @@ def create_servers(
             tls_args.append("--tls-replication")
             tls_args.append("yes")
     servers_to_check = set()
+    logging.info(f"Starting {nodes_count} nodes (shard_count={shard_count}, replica_count={replica_count})")
     # Start all servers
     for i in range(nodes_count):
         port = ports[i] if ports else None

From f46e8657cf1c7a59ad7a2374a54e5f84f2399a46 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 11:54:14 -0700
Subject: [PATCH 060/106] Enable one replica

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle                                   | 4 ++--
 java/integTest/src/test/java/glide/cluster/ValkeyCluster.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index d44a7f2592..5553ca542e 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -94,7 +94,7 @@ tasks.register('startCluster') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '0', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
@@ -113,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '0', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 1c93e1b995..1c7bb88517 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -120,7 +120,7 @@ public ValkeyCluster(
 
     /** Constructor with default values */
     public ValkeyCluster(boolean tls) throws IOException, InterruptedException {
-        this(tls, false, 3, 0, null, null);
+        this(tls, false, 3, 1, null, null);
     }
 
     private void parseClusterScriptStartOutput(String output) {

From 69aaaf4767f5206b993db45d226c533b26e2b853 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 11:54:26 -0700
Subject: [PATCH 061/106] Add cluster bus diagnostics for WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 61 +++++++++++++++++++++++++++++++++-------
 1 file changed, 51 insertions(+), 10 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 7b33eb1320..5d56cad45f 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -521,23 +521,64 @@ def create_cluster(
 ):
     tic = time.perf_counter()
     servers_tuple = (str(server) for server in servers)
+    logging.info(f"Creating cluster with {len(servers)} servers: {list(str(s) for s in servers)}")
+    logging.info(f"Cluster replicas: {replica_count}")
+    
+    # Check cluster bus ports are accessible
+    logging.info("Checking cluster bus ports...")
+    for server in servers:
+        cluster_bus_port = server.port + 10000
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(1)
+            result = sock.connect_ex((server.host, cluster_bus_port))
+            if result == 0:
+                logging.info(f"Cluster bus port {server.host}:{cluster_bus_port} is accessible")
+            else:
+                logging.warning(f"Cluster bus port {server.host}:{cluster_bus_port} is not accessible (result: {result})")
+            sock.close()
+        except Exception as e:
+            logging.warning(f"Failed to check cluster bus port {server.host}:{cluster_bus_port}: {e}")
+    
     logging.debug("## Starting cluster creation...")
+    
+    cmd_args = [
+        get_cli_command(),
+        *get_cli_option_args(cluster_folder, use_tls),
+        "--cluster",
+        "create",
+        *servers_tuple,
+        "--cluster-replicas",
+        str(replica_count),
+        "--cluster-yes",
+    ]
+    logging.info(f"Executing cluster create command: {' '.join(cmd_args)}")
+    
     p = subprocess.Popen(
-        [
-            get_cli_command(),
-            *get_cli_option_args(cluster_folder, use_tls),
-            "--cluster",
-            "create",
-            *servers_tuple,
-            "--cluster-replicas",
-            str(replica_count),
-            "--cluster-yes",
-        ],
+        cmd_args,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         text=True,
     )
     output, err = p.communicate(timeout=40)
+    logging.info(f"Cluster create output: {output}")
+    if err:
+        logging.error(f"Cluster create error: {err}")
+    
+    # Parse the output to see what happened
+    if ">>> Performing hash slots allocation on" in output:
+        logging.info("Cluster create command started slot allocation")
+    if ">>> Nodes configuration updated" in output:
+        logging.info("Cluster nodes configuration was updated")
+    if ">>> Assign a different config epoch to each node" in output:
+        logging.info("Config epochs assigned to nodes")
+    if ">>> Sending CLUSTER MEET messages to join the cluster" in output:
+        logging.info("CLUSTER MEET messages sent")
+    if "Waiting for the cluster to join" in output:
+        logging.info("Waiting for cluster to join...")
+    if ">>> Performing Cluster Check" in output:
+        logging.info("Performing cluster check")
+        
     if err or "[OK] All 16384 slots covered." not in output:
         raise Exception(f"Failed to create cluster: {err if err else output}")
 

From ccde021a822389ffea5f0521553c7fdd5ecbacd9 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 14:35:19 -0700
Subject: [PATCH 062/106] Handle slower replica syncing on WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 5d56cad45f..df120fb178 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -584,6 +584,36 @@ def create_cluster(
 
     wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
     wait_for_all_topology_views(servers, cluster_folder, use_tls)
+    
+    # Verify replicas are properly synced
+    logging.info("Verifying replica synchronization...")
+    replica_count_actual = 0
+    for server in servers:
+        cmd_args = [
+            get_cli_command(),
+            "-h",
+            server.host,
+            "-p", 
+            str(server.port),
+            *get_cli_option_args(cluster_folder, use_tls),
+            "cluster",
+            "nodes",
+        ]
+        output = redis_cli_run_command(cmd_args)
+        if output:
+            # Count lines that contain "slave" and "connected"
+            for line in output.strip().split('\n'):
+                if 'slave' in line and 'connected' in line:
+                    replica_count_actual += 1
+                    logging.info(f"Found connected replica: {line.split()[1]}")
+    
+    expected_replicas = len(servers) - shard_count  # total nodes - master nodes
+    logging.info(f"Expected replicas: {expected_replicas}, Found connected replicas: {replica_count_actual}")
+    
+    if replica_count_actual != expected_replicas:
+        logging.warning(f"Replica count mismatch! Expected {expected_replicas}, found {replica_count_actual}")
+    else:
+        logging.info("All replicas are properly connected and synced!")
     print_servers_json(servers)
 
     logging.debug("The cluster was successfully created!")
@@ -719,7 +749,7 @@ def wait_for_all_topology_views(
 ):
     """
     Wait for each of the nodes to have a topology view that contains all nodes.
-    Only when a replica finished syncing and loading, it will be included in the CLUSTER SLOTS output.
+    Use CLUSTER NODES to see all nodes (masters and replicas).
     """
     for server in servers:
         cmd_args = [
@@ -730,7 +760,7 @@ def wait_for_all_topology_views(
             str(server.port),
             *get_cli_option_args(cluster_folder, use_tls),
             "cluster",
-            "slots",
+            "nodes",
         ]
         logging.debug(f"Executing: {cmd_args}")
         retries = 160

From 55bf0729365e8580ce17716ddd1fe092be759295 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 15:14:24 -0700
Subject: [PATCH 063/106] Revert to 3 replicas as before

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 5553ca542e..a6efff4650 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -113,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os

From 8ad603ffd7a6ceb885c2be5c4f7dff1c7f0fbe76 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 15:14:42 -0700
Subject: [PATCH 064/106] Use a more lightweight check for replica verification

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 31 ++++++++++++-------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index df120fb178..ec99866d5b 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -585,35 +585,28 @@ def create_cluster(
     wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
     wait_for_all_topology_views(servers, cluster_folder, use_tls)
     
-    # Verify replicas are properly synced
-    logging.info("Verifying replica synchronization...")
-    replica_count_actual = 0
-    for server in servers:
+    # Only do detailed replica verification if we have replicas and are in a slow environment
+    if replica_count > 0:
+        logging.info("Verifying replica synchronization...")
+        # Quick check - just verify we can see all nodes in cluster
         cmd_args = [
             get_cli_command(),
             "-h",
-            server.host,
+            servers[0].host,
             "-p", 
-            str(server.port),
+            str(servers[0].port),
             *get_cli_option_args(cluster_folder, use_tls),
             "cluster",
             "nodes",
         ]
         output = redis_cli_run_command(cmd_args)
         if output:
-            # Count lines that contain "slave" and "connected"
-            for line in output.strip().split('\n'):
-                if 'slave' in line and 'connected' in line:
-                    replica_count_actual += 1
-                    logging.info(f"Found connected replica: {line.split()[1]}")
-    
-    expected_replicas = len(servers) - shard_count  # total nodes - master nodes
-    logging.info(f"Expected replicas: {expected_replicas}, Found connected replicas: {replica_count_actual}")
-    
-    if replica_count_actual != expected_replicas:
-        logging.warning(f"Replica count mismatch! Expected {expected_replicas}, found {replica_count_actual}")
-    else:
-        logging.info("All replicas are properly connected and synced!")
+            connected_nodes = len([line for line in output.strip().split('\n') if 'connected' in line])
+            logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")
+            if connected_nodes != len(servers):
+                logging.warning(f"Not all nodes are connected! Expected {len(servers)}, found {connected_nodes}")
+        else:
+            logging.warning("Could not verify cluster node status")
     print_servers_json(servers)
 
     logging.debug("The cluster was successfully created!")

From b165f1c14b1d217bd696a1654c2513c8c68c297a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 15:36:54 -0700
Subject: [PATCH 065/106] Add specialization for replica detection for WSL
 environments

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index ec99866d5b..06be9377c3 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -583,7 +583,7 @@ def create_cluster(
         raise Exception(f"Failed to create cluster: {err if err else output}")
 
     wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
-    wait_for_all_topology_views(servers, cluster_folder, use_tls)
+    wait_for_all_topology_views(servers, cluster_folder, use_tls, replica_count)
     
     # Only do detailed replica verification if we have replicas and are in a slow environment
     if replica_count > 0:
@@ -600,7 +600,7 @@ def create_cluster(
             "nodes",
         ]
         output = redis_cli_run_command(cmd_args)
-        if output:
+        if output is not None:
             connected_nodes = len([line for line in output.strip().split('\n') if 'connected' in line])
             logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")
             if connected_nodes != len(servers):
@@ -738,11 +738,11 @@ def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
 
 
 def wait_for_all_topology_views(
-    servers: List[Server], cluster_folder: str, use_tls: bool
+    servers: List[Server], cluster_folder: str, use_tls: bool, replica_count: int = 0
 ):
     """
     Wait for each of the nodes to have a topology view that contains all nodes.
-    Use CLUSTER NODES to see all nodes (masters and replicas).
+    Only when a replica finished syncing and loading, it will be included in the CLUSTER SLOTS output.
     """
     for server in servers:
         cmd_args = [
@@ -753,15 +753,28 @@ def wait_for_all_topology_views(
             str(server.port),
             *get_cli_option_args(cluster_folder, use_tls),
             "cluster",
-            "nodes",
+            "slots",
         ]
         logging.debug(f"Executing: {cmd_args}")
-        retries = 160
+        
+        # Detect WSL environment and adjust behavior
+        is_wsl = os.path.exists('/proc/version') and 'microsoft' in open('/proc/version').read().lower()
+        retries = 320 if is_wsl else 160  # Double timeout for WSL
+        
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
             if output is not None:
                 host_count = output.count(f"{server.host}")
-                if host_count == len(servers):
+                expected_count = len(servers)
+                
+                # WSL-specific: Accept when we see all masters (replicas may not appear in CLUSTER SLOTS)
+                if is_wsl and replica_count > 0:
+                    master_count = len(servers) // (1 + replica_count)
+                    if host_count >= master_count:
+                        logging.info(f"WSL: Found {host_count} nodes (expected masters: {master_count}), continuing...")
+                        expected_count = host_count  # Accept current count for WSL
+                
+                if host_count == expected_count:
                     # Server is ready, get the node's role
                     cmd_args = [
                         get_cli_command(),

From ee40a1a361adb99cbe425bff6549ec4e2cafa9bc Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 15:47:31 -0700
Subject: [PATCH 066/106] Linting fix

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 06be9377c3..ade9b06850 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -599,7 +599,7 @@ def create_cluster(
             "cluster",
             "nodes",
         ]
-        output = redis_cli_run_command(cmd_args)
+        output: Optional[str] = redis_cli_run_command(cmd_args)
         if output is not None:
             connected_nodes = len([line for line in output.strip().split('\n') if 'connected' in line])
             logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")

From d025c916d91522ea5ad8a5dd256ee6a59e462391 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 15:59:29 -0700
Subject: [PATCH 067/106] Linter fixes

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index ade9b06850..52418c20a8 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -599,9 +599,9 @@ def create_cluster(
             "cluster",
             "nodes",
         ]
-        output: Optional[str] = redis_cli_run_command(cmd_args)
-        if output is not None:
-            connected_nodes = len([line for line in output.strip().split('\n') if 'connected' in line])
+        cluster_output: Optional[str] = redis_cli_run_command(cmd_args)
+        if cluster_output is not None:
+            connected_nodes = len([line for line in cluster_output.strip().split('\n') if 'connected' in line])
             logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")
             if connected_nodes != len(servers):
                 logging.warning(f"Not all nodes are connected! Expected {len(servers)}, found {connected_nodes}")

From 3fcf541e732c7901c78cbf904a57725b2ac535c3 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 16:19:48 -0700
Subject: [PATCH 068/106] Fix cluster_manager.py argument order

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/cluster/ValkeyCluster.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 1c7bb88517..ca2ecad8ae 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -61,6 +61,8 @@ public ValkeyCluster(
             List<String> command = new ArrayList<>();
             command.addAll(getPythonCommand());
             command.add(SCRIPT_FILE.toString());
+            
+            command.add("start");  // Action must come first
 
             if (tls) {
                 command.add("--tls");
@@ -71,8 +73,6 @@ public ValkeyCluster(
             command.add("-r");
             command.add(String.valueOf(replicaCount));
 
-            command.add("start");
-
             // Add host parameter - use environment variable or default to localhost
             String host = System.getenv("VALKEY_INTEG_TEST_IP");
             if (host == null || host.isEmpty()) {

From 953e5c2a095f8efd939f7ae2149363cb940f6597 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 16:41:33 -0700
Subject: [PATCH 069/106] Spotless

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/cluster/ValkeyCluster.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index ca2ecad8ae..2ee5c6fa1e 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -61,8 +61,8 @@ public ValkeyCluster(
             List<String> command = new ArrayList<>();
             command.addAll(getPythonCommand());
             command.add(SCRIPT_FILE.toString());
-            
-            command.add("start");  // Action must come first
+
+            command.add("start"); // Action must come first
 
             if (tls) {
                 command.add("--tls");

From d803c18b87551cb7e8391acf633d2b3a33f28ff8 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 23 Oct 2025 17:13:34 -0700
Subject: [PATCH 070/106] Replica debugging

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 52418c20a8..7b457119bb 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -603,6 +603,17 @@ def create_cluster(
         if cluster_output is not None:
             connected_nodes = len([line for line in cluster_output.strip().split('\n') if 'connected' in line])
             logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")
+            
+            # Show detailed node status
+            logging.info("=== CLUSTER NODES STATUS ===")
+            for line in cluster_output.strip().split('\n'):
+                if 'master' in line:
+                    logging.info(f"MASTER: {line}")
+                elif 'slave' in line:
+                    status = "CONNECTED" if 'connected' in line else "DISCONNECTED"
+                    logging.info(f"REPLICA ({status}): {line}")
+            logging.info("=== END CLUSTER STATUS ===")
+            
             if connected_nodes != len(servers):
                 logging.warning(f"Not all nodes are connected! Expected {len(servers)}, found {connected_nodes}")
         else:

From 93d8f52eceaa63e14420636f868b4b31ac4e3ee7 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 05:42:21 -0700
Subject: [PATCH 071/106] Debugging replica issues

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 47 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 7b457119bb..1b88628825 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -15,6 +15,10 @@
 import string
 import subprocess
 import time
+try:
+    import psutil
+except ImportError:
+    psutil = None
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -588,6 +592,49 @@ def create_cluster(
     # Only do detailed replica verification if we have replicas and are in a slow environment
     if replica_count > 0:
         logging.info("Verifying replica synchronization...")
+        
+        # First, check if all server processes are still running
+        logging.info("=== CHECKING SERVER PROCESSES ===")
+        running_servers = 0
+        dead_servers = 0
+        for i, server in enumerate(servers):
+            try:
+                # Check if process is still running
+                if psutil is not None:
+                    if psutil.pid_exists(server.pid):
+                        proc = psutil.Process(server.pid)
+                        if proc.is_running() and proc.status() != psutil.STATUS_ZOMBIE:
+                            running_servers += 1
+                            logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - RUNNING")
+                        else:
+                            dead_servers += 1
+                            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - ZOMBIE/DEAD")
+                    else:
+                        dead_servers += 1
+                        logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - PROCESS NOT FOUND")
+                else:
+                    # Fallback: try to connect to the port to see if server is responsive
+                    try:
+                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        sock.settimeout(1)
+                        result = sock.connect_ex((server.host, server.port))
+                        sock.close()
+                        if result == 0:
+                            running_servers += 1
+                            logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
+                        else:
+                            dead_servers += 1
+                            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
+                    except Exception as e:
+                        dead_servers += 1
+                        logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - CONNECTION ERROR: {e}")
+            except Exception as e:
+                dead_servers += 1
+                logging.error(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - ERROR: {e}")
+        
+        logging.info(f"Process status: {running_servers} running, {dead_servers} dead/missing")
+        logging.info("=== END PROCESS CHECK ===")
+        
         # Quick check - just verify we can see all nodes in cluster
         cmd_args = [
             get_cli_command(),

From 14d5d43ea4f70fd16103e26736cb0b4e6db933a2 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 11:56:46 -0700
Subject: [PATCH 072/106] Move debugging sooner

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 39 ++++++++++++++++++++++++++++++---------
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 1b88628825..393fb69b93 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -569,6 +569,26 @@ def create_cluster(
     if err:
         logging.error(f"Cluster create error: {err}")
     
+    # IMMEDIATE debugging - check processes right after cluster create, before any waiting
+    if replica_count > 0:
+        logging.info("=== IMMEDIATE PROCESS CHECK (before waiting) ===")
+        running_count = 0
+        for i, server in enumerate(servers):
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(0.5)  # Very quick check
+                result = sock.connect_ex((server.host, server.port))
+                sock.close()
+                if result == 0:
+                    running_count += 1
+                    logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
+                else:
+                    logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
+            except Exception as e:
+                logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - ERROR: {e}")
+        logging.info(f"IMMEDIATE STATUS: {running_count}/{len(servers)} servers responsive")
+        logging.info("=== END IMMEDIATE CHECK ===")
+    
     # Parse the output to see what happened
     if ">>> Performing hash slots allocation on" in output:
         logging.info("Cluster create command started slot allocation")
@@ -586,15 +606,9 @@ def create_cluster(
     if err or "[OK] All 16384 slots covered." not in output:
         raise Exception(f"Failed to create cluster: {err if err else output}")
 
-    wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
-    wait_for_all_topology_views(servers, cluster_folder, use_tls, replica_count)
-    
-    # Only do detailed replica verification if we have replicas and are in a slow environment
+    # Check server processes immediately after cluster creation, before waiting for topology
     if replica_count > 0:
-        logging.info("Verifying replica synchronization...")
-        
-        # First, check if all server processes are still running
-        logging.info("=== CHECKING SERVER PROCESSES ===")
+        logging.info("=== CHECKING SERVER PROCESSES AFTER CLUSTER CREATE ===")
         running_servers = 0
         dead_servers = 0
         for i, server in enumerate(servers):
@@ -632,8 +646,15 @@ def create_cluster(
                 dead_servers += 1
                 logging.error(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - ERROR: {e}")
         
-        logging.info(f"Process status: {running_servers} running, {dead_servers} dead/missing")
+        logging.info(f"Process status after cluster create: {running_servers} running, {dead_servers} dead/missing")
         logging.info("=== END PROCESS CHECK ===")
+
+    wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
+    wait_for_all_topology_views(servers, cluster_folder, use_tls, replica_count)
+    
+    # Only do detailed replica verification if we have replicas and are in a slow environment
+    if replica_count > 0:
+        logging.info("Verifying replica synchronization...")
         
         # Quick check - just verify we can see all nodes in cluster
         cmd_args = [

From f968b024db297dd0dbf1155630c2fc28fd44c85d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 11:57:06 -0700
Subject: [PATCH 073/106] Increase workflow timeout on Windows specifically

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 321f36d0d6..e993dfb646 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -94,7 +94,7 @@ jobs:
     test-java:
         name: Java Tests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:
@@ -219,7 +219,7 @@ jobs:
     test-pubsub:
         name: Java PubSubTests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:

From 7f6c863f9e004a229b4ac0ac183f7b7deac9128b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 12:49:43 -0700
Subject: [PATCH 074/106] Use the system temp directory for OpenTelemetryTests

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/OpenTelemetryTests.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/integTest/src/test/java/glide/OpenTelemetryTests.java b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
index eab3748aea..3fbd4f5313 100644
--- a/java/integTest/src/test/java/glide/OpenTelemetryTests.java
+++ b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
@@ -25,7 +25,7 @@
 @Timeout(30) // seconds
 public class OpenTelemetryTests {
 
-    private static final String VALID_ENDPOINT_TRACES = "/tmp/spans.json";
+    private static final String VALID_ENDPOINT_TRACES = System.getProperty("java.io.tmpdir") + "spans.json";
     private static final String VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
     private static final String VALID_ENDPOINT_METRICS = "https://valid-endpoint/v1/metrics";
     private static GlideClusterClient client;

From 571a862d317022a04f7d698062b343cc59a8bc83 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 12:49:56 -0700
Subject: [PATCH 075/106] More diagnostics for replica issue

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 44 ++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 393fb69b93..e023ceb875 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -447,6 +447,8 @@ def create_servers(
     logging.debug("## Creating servers")
     ready_servers: List[Server] = []
     nodes_count = shard_count * (1 + replica_count)
+    logging.info(f"DEBUG: create_servers called with shard_count={shard_count}, replica_count={replica_count}")
+    logging.info(f"DEBUG: Expected nodes_count = {shard_count} * (1 + {replica_count}) = {nodes_count}")
     tls_args = []
     if tls is True:
         if should_generate_new_tls_certs():
@@ -513,6 +515,9 @@ def create_servers(
     logging.debug("All servers are up!")
     toc = time.perf_counter()
     logging.debug(f"create_servers() Elapsed time: {toc - tic:0.4f}")
+    logging.info(f"DEBUG: create_servers returning {len(ready_servers)} servers (expected {nodes_count})")
+    for i, server in enumerate(ready_servers):
+        logging.info(f"DEBUG: Returning server {i+1}: {server.host}:{server.port}")
     return ready_servers
 
 
@@ -569,25 +574,30 @@ def create_cluster(
     if err:
         logging.error(f"Cluster create error: {err}")
     
+    # UNCONDITIONAL debugging - always check processes after cluster create
+    logging.info("=== IMMEDIATE PROCESS CHECK (ALWAYS RUNS) ===")
+    running_count = 0
+    for i, server in enumerate(servers):
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(0.5)  # Very quick check
+            result = sock.connect_ex((server.host, server.port))
+            sock.close()
+            if result == 0:
+                running_count += 1
+                logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
+            else:
+                logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
+        except Exception as e:
+            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - ERROR: {e}")
+    logging.info(f"IMMEDIATE STATUS: {running_count}/{len(servers)} servers responsive")
+    logging.info("=== END IMMEDIATE CHECK ===")
+    
     # IMMEDIATE debugging - check processes right after cluster create, before any waiting
     if replica_count > 0:
-        logging.info("=== IMMEDIATE PROCESS CHECK (before waiting) ===")
-        running_count = 0
-        for i, server in enumerate(servers):
-            try:
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.settimeout(0.5)  # Very quick check
-                result = sock.connect_ex((server.host, server.port))
-                sock.close()
-                if result == 0:
-                    running_count += 1
-                    logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
-                else:
-                    logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
-            except Exception as e:
-                logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - ERROR: {e}")
-        logging.info(f"IMMEDIATE STATUS: {running_count}/{len(servers)} servers responsive")
-        logging.info("=== END IMMEDIATE CHECK ===")
+        logging.info("=== REPLICA-SPECIFIC CHECK ===")
+        logging.info(f"Expected: {len(servers)} total servers ({len(servers) // (1 + replica_count)} masters + {len(servers) - len(servers) // (1 + replica_count)} replicas)")
+        logging.info("=== END REPLICA CHECK ===")
     
     # Parse the output to see what happened
     if ">>> Performing hash slots allocation on" in output:

From 8ac24eb12dd11582cd11278d70e482280692039a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 13:42:21 -0700
Subject: [PATCH 076/106] spotless

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/OpenTelemetryTests.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/java/integTest/src/test/java/glide/OpenTelemetryTests.java b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
index 3fbd4f5313..2413404051 100644
--- a/java/integTest/src/test/java/glide/OpenTelemetryTests.java
+++ b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
@@ -25,7 +25,8 @@
 @Timeout(30) // seconds
 public class OpenTelemetryTests {
 
-    private static final String VALID_ENDPOINT_TRACES = System.getProperty("java.io.tmpdir") + "spans.json";
+    private static final String VALID_ENDPOINT_TRACES =
+            System.getProperty("java.io.tmpdir") + "spans.json";
     private static final String VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
     private static final String VALID_ENDPOINT_METRICS = "https://valid-endpoint/v1/metrics";
     private static GlideClusterClient client;

From 7644d913281ac1dfd177b44957824538927fd323 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 14:36:31 -0700
Subject: [PATCH 077/106] Fix OpenTelemetry test issue with filename

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/src/test/java/glide/OpenTelemetryTests.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/integTest/src/test/java/glide/OpenTelemetryTests.java b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
index 2413404051..ae4ff95d2a 100644
--- a/java/integTest/src/test/java/glide/OpenTelemetryTests.java
+++ b/java/integTest/src/test/java/glide/OpenTelemetryTests.java
@@ -26,7 +26,7 @@
 public class OpenTelemetryTests {
 
     private static final String VALID_ENDPOINT_TRACES =
-            System.getProperty("java.io.tmpdir") + "spans.json";
+            System.getProperty("java.io.tmpdir") + System.getProperty("file.separator") + "spans.json";
     private static final String VALID_FILE_ENDPOINT_TRACES = "file://" + VALID_ENDPOINT_TRACES;
     private static final String VALID_ENDPOINT_METRICS = "https://valid-endpoint/v1/metrics";
     private static GlideClusterClient client;

From 5a65e2b3c0a6d3ab9fc27998db2be3ef92c536bc Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 14:41:36 -0700
Subject: [PATCH 078/106] Track if the native lib is already loaded

- Avoid flakiness on Windows due to trying to load/unload/delete the library too quickly

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../main/java/glide/ffi/resolvers/NativeUtils.java    | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
index 6d3a9e2800..55f3d6ea04 100644
--- a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
+++ b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
@@ -31,10 +31,18 @@ public class NativeUtils {
     /** Temporary directory which will contain the dynamic library files. */
     private static File temporaryDir;
 
+    /** Track if the Glide library has already been loaded */
+    private static volatile boolean glideLibLoaded = false;
+
     /** Private constructor - this class will never be instanced */
     private NativeUtils() {}
 
-    public static void loadGlideLib() {
+    public static synchronized void loadGlideLib() {
+        // Check if already loaded to avoid multiple loads
+        if (glideLibLoaded) {
+            return;
+        }
+        
         String glideLib = "/libglide_rs";
         try {
             String osName = System.getProperty("os.name").toLowerCase();
@@ -48,6 +56,7 @@ public static void loadGlideLib() {
                 throw new UnsupportedOperationException(
                         "OS not supported. Glide is only available on Mac OS, Linux, and Windows systems.");
             }
+            glideLibLoaded = true; // Mark as loaded after successful load
         } catch (java.io.IOException e) {
             e.printStackTrace();
         }

From 61574b71135c65ffa6e886fccbc35f7ee760c5ab Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 14:58:03 -0700
Subject: [PATCH 079/106] spotless

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
index 55f3d6ea04..a89681aa5f 100644
--- a/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
+++ b/java/client/src/main/java/glide/ffi/resolvers/NativeUtils.java
@@ -42,7 +42,7 @@ public static synchronized void loadGlideLib() {
         if (glideLibLoaded) {
             return;
         }
-        
+
         String glideLib = "/libglide_rs";
         try {
             String osName = System.getProperty("os.name").toLowerCase();

From 56b22fdf100472785d92a82a30aeb6a92e833ead Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 14:59:24 -0700
Subject: [PATCH 080/106] More

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 76 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 75 insertions(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index e023ceb875..f381090cf0 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -16,7 +16,7 @@
 import subprocess
 import time
 try:
-    import psutil
+    import psutil  # type: ignore
 except ImportError:
     psutil = None
 from datetime import datetime, timezone
@@ -528,6 +528,10 @@ def create_cluster(
     cluster_folder: str,
     use_tls: bool,
 ):
+    logging.info(f"DEBUG: create_cluster() called with {len(servers)} servers")
+    for i, server in enumerate(servers):
+        logging.info(f"DEBUG: create_cluster() server {i+1}: {server.host}:{server.port}")
+    
     tic = time.perf_counter()
     servers_tuple = (str(server) for server in servers)
     logging.info(f"Creating cluster with {len(servers)} servers: {list(str(s) for s in servers)}")
@@ -591,6 +595,76 @@ def create_cluster(
         except Exception as e:
             logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - ERROR: {e}")
     logging.info(f"IMMEDIATE STATUS: {running_count}/{len(servers)} servers responsive")
+    
+    # WSL NETWORKING DIAGNOSTICS (fast checks only)
+    if len(servers) > 6:  # Only run for high-replica clusters
+        logging.info("=== WSL NETWORKING DIAGNOSTICS ===")
+        
+        # 1. Cluster bus connectivity (sample only first 3 servers to save time)
+        logging.info("Testing cluster bus connectivity (sample)...")
+        for i in range(min(3, len(servers))):
+            server = servers[i]
+            cluster_bus_port = server.port + 10000
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(0.3)
+                result = sock.connect_ex((server.host, cluster_bus_port))
+                sock.close()
+                status = "ACCESSIBLE" if result == 0 else "NOT_ACCESSIBLE"
+                logging.info(f"Cluster bus {server.host}:{cluster_bus_port} - {status}")
+            except Exception as e:
+                logging.warning(f"Cluster bus {server.host}:{cluster_bus_port} - ERROR: {e}")
+        
+        # 2. Concurrent connection test (quick)
+        logging.info("Testing concurrent connections...")
+        open_sockets = []
+        max_concurrent = 0
+        for i, server in enumerate(servers):
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(0.2)
+                sock.connect((server.host, server.port))
+                open_sockets.append(sock)
+                max_concurrent = i + 1
+            except Exception as e:
+                logging.warning(f"Concurrent connection limit reached at {i+1}: {e}")
+                break
+        # Close all sockets
+        for sock in open_sockets:
+            try:
+                sock.close()
+            except:
+                pass
+        logging.info(f"Max concurrent connections: {max_concurrent}/{len(servers)}")
+        
+        # 3. WSL resource check (if psutil available)
+        if psutil is not None:
+            try:
+                mem = psutil.virtual_memory()
+                logging.info(f"WSL Memory: {mem.percent:.1f}% used ({mem.available // (1024*1024)} MB available)")
+                logging.info(f"WSL Process count: {len(psutil.pids())}")
+            except Exception as e:
+                logging.warning(f"Resource check failed: {e}")
+        
+        # 4. Individual server health (ping test - very fast)
+        logging.info("Testing individual server health...")
+        healthy_servers = 0
+        for i, server in enumerate(servers[:5]):  # Test first 5 only to save time
+            try:
+                ping_result: Optional[str] = redis_cli_run_command([
+                    get_cli_command(), "-h", server.host, "-p", str(server.port), 
+                    "--connect-timeout", "1", "ping"
+                ])
+                if ping_result is not None and "PONG" in ping_result:
+                    healthy_servers += 1
+                    logging.info(f"Server {i+1} health: OK")
+                else:
+                    logging.warning(f"Server {i+1} health: NO PONG")
+            except Exception as e:
+                logging.warning(f"Server {i+1} health: ERROR - {e}")
+        logging.info(f"Healthy servers (sample): {healthy_servers}/5")
+        logging.info("=== END WSL DIAGNOSTICS ===")
+    
     logging.info("=== END IMMEDIATE CHECK ===")
     
     # IMMEDIATE debugging - check processes right after cluster create, before any waiting

From 2e50e79b4e8980369cd463526495d124b8f802b4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 15:49:07 -0700
Subject: [PATCH 081/106] Run the build after optimizing WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 58 ++++++++++++++++++++++++++++++--------
 1 file changed, 46 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index e993dfb646..60f888ef7b 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -161,22 +161,27 @@ jobs:
                   # Create python3 symlink for Windows
                   ln -sf $(which python) /usr/bin/python3
 
-            - name: Build java client
-              working-directory: java
-              env:
-                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
-              shell: bash
-              run: |
-                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
-                      ./gradlew.bat --build-cache --continue build -x javadoc
-                  else
-                      ./gradlew --build-cache --continue build -x javadoc
-                  fi
-
             - name: Setup networking and verify Valkey (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
+                  # Optimize WSL for better performance
+                  Write-Host "Optimizing WSL configuration..."
+                  
+                  # Create WSL config for better performance
+                  $wslConfig = @"
+          [wsl2]
+          memory=6GB
+          processors=4
+          swap=2GB
+          localhostForwarding=true
+          "@
+                  $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+                  
+                  # Restart WSL to apply config
+                  wsl --shutdown
+                  Start-Sleep -Seconds 3
+                  
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
@@ -188,6 +193,18 @@ jobs:
                   # Verify Valkey is running
                   wsl -- redis-cli ping
 
+            - name: Build java client
+              working-directory: java
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache --continue build -x javadoc
+                  else
+                      ./gradlew --build-cache --continue build -x javadoc
+                  fi
+
             - name: Ensure no skipped files by linter
               working-directory: java
               shell: bash
@@ -281,6 +298,23 @@ jobs:
               if: ${{ matrix.host.OS == 'windows' }}
               shell: pwsh
               run: |
+                  # Optimize WSL for better performance (PubSub tests)
+                  Write-Host "Optimizing WSL configuration for PubSub tests..."
+                  
+                  # Create WSL config for better performance
+                  $wslConfig = @"
+          [wsl2]
+          memory=6GB
+          processors=4
+          swap=2GB
+          localhostForwarding=true
+          "@
+                  $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+                  
+                  # Restart WSL to apply config
+                  wsl --shutdown
+                  Start-Sleep -Seconds 3
+                  
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV

From 8fd8b8e7ce9228dd97d65ecaba2a548296599813 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 16:07:55 -0700
Subject: [PATCH 082/106] Use only 1 replica to reduce resource usage

Signed-off-by: James Duong <duong.james@gmail.com>
---
 java/integTest/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index a6efff4650..5553ca542e 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -113,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os

From ce077a596064173b0456299a595602d242e196fc Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 16:09:45 -0700
Subject: [PATCH 083/106] More diagnostics

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 74 ++++++++++++++++++++++++++++++++--------
 1 file changed, 60 insertions(+), 14 deletions(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index f381090cf0..9b0b40ede2 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -646,24 +646,70 @@ def create_cluster(
             except Exception as e:
                 logging.warning(f"Resource check failed: {e}")
         
-        # 4. Individual server health (ping test - very fast)
-        logging.info("Testing individual server health...")
-        healthy_servers = 0
-        for i, server in enumerate(servers[:5]):  # Test first 5 only to save time
+        # WSL NETWORKING DIAGNOSTICS (fast checks only)
+        if len(servers) > 6:  # Only run for high-replica clusters
+            logging.info("=== WSL NETWORKING DIAGNOSTICS ===")
+            
+            # 1. Detailed cluster nodes analysis
+            logging.info("Analyzing cluster topology...")
             try:
-                ping_result: Optional[str] = redis_cli_run_command([
-                    get_cli_command(), "-h", server.host, "-p", str(server.port), 
-                    "--connect-timeout", "1", "ping"
+                cluster_nodes_output = redis_cli_run_command([
+                    get_cli_command(), "-h", servers[0].host, "-p", str(servers[0].port),
+                    "cluster", "nodes"
                 ])
-                if ping_result is not None and "PONG" in ping_result:
-                    healthy_servers += 1
-                    logging.info(f"Server {i+1} health: OK")
+                if cluster_nodes_output:
+                    lines = cluster_nodes_output.strip().split('\n')
+                    logging.info(f"CLUSTER NODES returned {len(lines)} lines:")
+                    for i, line in enumerate(lines):
+                        if line.strip():
+                            # Parse node info: node_id host:port@cluster_port flags master/slave
+                            parts = line.split()
+                            if len(parts) >= 3:
+                                node_id = parts[0][:8]  # First 8 chars of node ID
+                                host_port = parts[1].split('@')[0]  # Remove cluster port
+                                flags = parts[2]
+                                logging.info(f"  Node {i+1}: {host_port} ({flags}) ID:{node_id}")
+                            else:
+                                logging.info(f"  Node {i+1}: {line.strip()}")
                 else:
-                    logging.warning(f"Server {i+1} health: NO PONG")
+                    logging.warning("CLUSTER NODES returned no output")
             except Exception as e:
-                logging.warning(f"Server {i+1} health: ERROR - {e}")
-        logging.info(f"Healthy servers (sample): {healthy_servers}/5")
-        logging.info("=== END WSL DIAGNOSTICS ===")
+                logging.error(f"Failed to get cluster nodes: {e}")
+            
+            # 2. Check cluster info from multiple nodes
+            logging.info("Checking cluster info from different nodes...")
+            for i in range(min(3, len(servers))):
+                server = servers[i]
+                try:
+                    cluster_info = redis_cli_run_command([
+                        get_cli_command(), "-h", server.host, "-p", str(server.port),
+                        "cluster", "info"
+                    ])
+                    if cluster_info and "cluster_known_nodes:" in cluster_info:
+                        known_nodes = [line for line in cluster_info.split('\n') if 'cluster_known_nodes:' in line]
+                        if known_nodes:
+                            logging.info(f"  Server {server.host}:{server.port} sees: {known_nodes[0]}")
+                except Exception as e:
+                    logging.warning(f"  Server {server.host}:{server.port} cluster info failed: {e}")
+            
+            # 3. Individual server health (ping test - very fast) - FIXED: Remove --connect-timeout
+            logging.info("Testing individual server health...")
+            healthy_servers = 0
+            for i, server in enumerate(servers[:5]):  # Test first 5 only to save time
+                try:
+                    ping_result: Optional[str] = redis_cli_run_command([
+                        get_cli_command(), "-h", server.host, "-p", str(server.port), 
+                        "ping"  # Removed --connect-timeout which caused the error
+                    ])
+                    if ping_result is not None and "PONG" in ping_result:
+                        healthy_servers += 1
+                        logging.info(f"Server {i+1} health: OK")
+                    else:
+                        logging.warning(f"Server {i+1} health: NO PONG")
+                except Exception as e:
+                    logging.warning(f"Server {i+1} health: ERROR - {e}")
+            logging.info(f"Healthy servers (sample): {healthy_servers}/5")
+            logging.info("=== END WSL DIAGNOSTICS ===")
     
     logging.info("=== END IMMEDIATE CHECK ===")
     

From 69ad2cd39fbe1befbd4b5885e5f42d4a74987a5a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 16:25:43 -0700
Subject: [PATCH 084/106] Fix YAML syntax error

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 60f888ef7b..c3a084f892 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -167,21 +167,21 @@ jobs:
               run: |
                   # Optimize WSL for better performance
                   Write-Host "Optimizing WSL configuration..."
-                  
+
                   # Create WSL config for better performance
                   $wslConfig = @"
-          [wsl2]
-          memory=6GB
-          processors=4
-          swap=2GB
-          localhostForwarding=true
-          "@
+                  [wsl2]
+                  memory=6GB
+                  processors=4
+                  swap=2GB
+                  localhostForwarding=true
+                  "@
                   $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
-                  
+
                   # Restart WSL to apply config
                   wsl --shutdown
                   Start-Sleep -Seconds 3
-                  
+
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
@@ -300,21 +300,21 @@ jobs:
               run: |
                   # Optimize WSL for better performance (PubSub tests)
                   Write-Host "Optimizing WSL configuration for PubSub tests..."
-                  
+
                   # Create WSL config for better performance
                   $wslConfig = @"
-          [wsl2]
-          memory=6GB
-          processors=4
-          swap=2GB
-          localhostForwarding=true
-          "@
+                  [wsl2]
+                  memory=6GB
+                  processors=4
+                  swap=2GB
+                  localhostForwarding=true
+                  "@
                   $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
-                  
+
                   # Restart WSL to apply config
                   wsl --shutdown
                   Start-Sleep -Seconds 3
-                  
+
                   # Read WSL IP from file written by engine installation
                   $wslIp = wsl -- cat /tmp/wsl_ip.txt
                   echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV

From 3d87d3a748880db39088f009128bf6cb87be6e8c Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 16:45:07 -0700
Subject: [PATCH 085/106] Remove faulty valkey server check in optimize WSL
 step

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/java.yml | 22 ++--------------------
 1 file changed, 2 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index c3a084f892..2ad0763384 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -182,16 +182,7 @@ jobs:
                   wsl --shutdown
                   Start-Sleep -Seconds 3
 
-                  # Read WSL IP from file written by engine installation
-                  $wslIp = wsl -- cat /tmp/wsl_ip.txt
-                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "VALKEY_INTEG_TEST_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
-                  Write-Host "WSL IP address: $wslIp"
-
-                  # Verify Valkey is running
-                  wsl -- redis-cli ping
+                  Write-Host "WSL optimization complete"
 
             - name: Build java client
               working-directory: java
@@ -315,16 +306,7 @@ jobs:
                   wsl --shutdown
                   Start-Sleep -Seconds 3
 
-                  # Read WSL IP from file written by engine installation
-                  $wslIp = wsl -- cat /tmp/wsl_ip.txt
-                  echo "WSL_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "VALKEY_INTEG_TEST_IP=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_HOST=$wslIp" >> $env:GITHUB_ENV
-                  echo "REDIS_PORT=6379" >> $env:GITHUB_ENV
-                  Write-Host "WSL IP address: $wslIp"
-
-                  # Verify Valkey is running
-                  wsl -- redis-cli ping
+                  Write-Host "WSL optimization complete"
 
             - name: Test pubsub
               working-directory: java

From c86c7854b3e661cf22ff49f03ff34adb932c1940 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 17:38:19 -0700
Subject: [PATCH 086/106] Add more diagnostics for replica issue

Signed-off-by: James Duong <duong.james@gmail.com>
---
 utils/cluster_manager.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index 9b0b40ede2..ed05d37115 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -673,8 +673,20 @@ def create_cluster(
                                 logging.info(f"  Node {i+1}: {line.strip()}")
                 else:
                     logging.warning("CLUSTER NODES returned no output")
+                    
+                # Also check CLUSTER SLOTS which is what Java client uses for routing
+                cluster_slots_output = redis_cli_run_command([
+                    get_cli_command(), "-h", servers[0].host, "-p", str(servers[0].port),
+                    "cluster", "slots"
+                ])
+                if cluster_slots_output:
+                    logging.info("CLUSTER SLOTS output:")
+                    logging.info(cluster_slots_output)
+                else:
+                    logging.warning("CLUSTER SLOTS returned no output - THIS IS THE ROUTING PROBLEM")
+                    
             except Exception as e:
-                logging.error(f"Failed to get cluster nodes: {e}")
+                logging.error(f"Failed to get cluster topology: {e}")
             
             # 2. Check cluster info from multiple nodes
             logging.info("Checking cluster info from different nodes...")

From dac2f3720ec1b52973192b4b37c075c6d8995afb Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 17:38:27 -0700
Subject: [PATCH 087/106] Various test fixes

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../src/test/java/glide/ConnectionTests.java  |  4 ++--
 .../src/test/java/glide/TestUtilities.java    | 19 +++++++++++++++++++
 .../java/glide/cluster/ClusterBatchTests.java |  1 +
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/java/integTest/src/test/java/glide/ConnectionTests.java b/java/integTest/src/test/java/glide/ConnectionTests.java
index f3059f0e54..1600adac27 100644
--- a/java/integTest/src/test/java/glide/ConnectionTests.java
+++ b/java/integTest/src/test/java/glide/ConnectionTests.java
@@ -251,7 +251,7 @@ public void test_routing_with_az_affinity_strategy_to_1_replica() {
     public void test_az_affinity_non_existing_az() {
         assumeTrue(SERVER_VERSION.isGreaterThanOrEqualTo("8.0.0"), "Skip for versions below 8");
 
-        int nGetCalls = 4;
+        int nGetCalls = 3; // Match number of replicas
         int nReplicaCalls = 1;
         String getCmdstat = String.format("cmdstat_get:calls=%d", nReplicaCalls);
 
@@ -272,7 +272,7 @@ public void test_az_affinity_non_existing_az() {
         //  We expect the calls to be distributed evenly among the replicas
         long matchingEntries =
                 infoData.values().stream().filter(value -> value.contains(getCmdstat)).count();
-        assertEquals(4, matchingEntries);
+        assertEquals(3, matchingEntries); // 3 replicas (1 per shard) instead of 4
         azTestClient.close();
     }
 
diff --git a/java/integTest/src/test/java/glide/TestUtilities.java b/java/integTest/src/test/java/glide/TestUtilities.java
index e1a2d8d0fd..58be87620c 100644
--- a/java/integTest/src/test/java/glide/TestUtilities.java
+++ b/java/integTest/src/test/java/glide/TestUtilities.java
@@ -19,6 +19,7 @@
 import glide.api.models.ClusterValue;
 import glide.api.models.GlideString;
 import glide.api.models.commands.InfoOptions.Section;
+import glide.api.models.configuration.AdvancedGlideClusterClientConfiguration;
 import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
@@ -193,6 +194,15 @@ public static <T> T[] concatenateArrays(T[]... arrays) {
             builder.address(
                     NodeAddress.builder().host(parts[0]).port(Integer.parseInt(parts[1])).build());
         }
+
+        // WSL-specific configuration to fix routing issues
+        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
+            builder.advancedConfiguration(
+                    AdvancedGlideClusterClientConfiguration.builder()
+                            .refreshTopologyFromInitialNodes(true)
+                            .build());
+        }
+
         return builder.useTLS(TLS);
     }
 
@@ -204,6 +214,15 @@ public static <T> T[] concatenateArrays(T[]... arrays) {
             builder.address(
                     NodeAddress.builder().host(parts[0]).port(Integer.parseInt(parts[1])).build());
         }
+
+        // WSL-specific configuration to fix routing issues
+        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
+            builder.advancedConfiguration(
+                    AdvancedGlideClusterClientConfiguration.builder()
+                            .refreshTopologyFromInitialNodes(true)
+                            .build());
+        }
+
         return builder.useTLS(TLS);
     }
 
diff --git a/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java b/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
index cc56be62fb..768a958850 100644
--- a/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
+++ b/java/integTest/src/test/java/glide/cluster/ClusterBatchTests.java
@@ -174,6 +174,7 @@ public void keyless_batches_with_group_of_commands(
     @SneakyThrows
     @ParameterizedTest
     @MethodSource("getClientsWithAtomic")
+    @Timeout(15)
     public void test_batch_large_values(GlideClusterClient clusterClient, boolean isAtomic) {
         // Skip on macOS - the macOS tests run on self hosted VMs which have resource limits
         // making this test flaky with "no buffer space available" errors. See -

From 2613fea50edb589f356543571ddbf7b622580758 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 24 Oct 2025 17:38:37 -0700
Subject: [PATCH 088/106] Optimize WSL

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 23 +++++++++++++++++++
 .github/workflows/java.yml                    | 23 -------------------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index b96e21cdcc..9593c3642f 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -91,6 +91,29 @@ runs:
               update: true
               additional-packages: build-essential git pkg-config libssl-dev python3 python3-pip
 
+        - name: Optimize WSL for better performance (Windows)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          shell: pwsh
+          run: |
+              # Optimize WSL for better performance before engine installation
+              Write-Host "Optimizing WSL configuration for engine build..."
+
+              # Create WSL config for better performance
+              $wslConfig = @"
+              [wsl2]
+              memory=6GB
+              processors=4
+              swap=2GB
+              localhostForwarding=true
+              "@
+              $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+
+              # Restart WSL to apply config
+              wsl --shutdown
+              Start-Sleep -Seconds 3
+
+              Write-Host "WSL optimization complete - ready for engine build"
+
         - name: Cache Valkey build
           if: "${{ inputs.engine-version }}"
           uses: actions/cache@v4
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 2ad0763384..47146b7576 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -161,29 +161,6 @@ jobs:
                   # Create python3 symlink for Windows
                   ln -sf $(which python) /usr/bin/python3
 
-            - name: Setup networking and verify Valkey (Windows)
-              if: ${{ matrix.host.OS == 'windows' }}
-              shell: pwsh
-              run: |
-                  # Optimize WSL for better performance
-                  Write-Host "Optimizing WSL configuration..."
-
-                  # Create WSL config for better performance
-                  $wslConfig = @"
-                  [wsl2]
-                  memory=6GB
-                  processors=4
-                  swap=2GB
-                  localhostForwarding=true
-                  "@
-                  $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
-
-                  # Restart WSL to apply config
-                  wsl --shutdown
-                  Start-Sleep -Seconds 3
-
-                  Write-Host "WSL optimization complete"
-
             - name: Build java client
               working-directory: java
               env:

From e71db0360d0e9d0308c3cf0b08cb56fde3eb462a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 27 Oct 2025 13:30:06 -0700
Subject: [PATCH 089/106] Remove WSL-specific behavior

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    |  43 +-
 java/integTest/build.gradle                   |   2 +-
 .../src/test/java/glide/ConnectionTests.java  |   4 +-
 .../src/test/java/glide/TestUtilities.java    |  19 -
 utils/cluster_manager.py                      | 419 +++---------------
 5 files changed, 59 insertions(+), 428 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 9593c3642f..a9367e2958 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -82,38 +82,6 @@ runs:
           with:
               python-version: "3.x"
 
-        - name: Setup WSL (Windows only)
-          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
-          uses: Vampire/setup-wsl@v6
-          with:
-              distribution: Ubuntu-22.04
-              use-cache: true
-              update: true
-              additional-packages: build-essential git pkg-config libssl-dev python3 python3-pip
-
-        - name: Optimize WSL for better performance (Windows)
-          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
-          shell: pwsh
-          run: |
-              # Optimize WSL for better performance before engine installation
-              Write-Host "Optimizing WSL configuration for engine build..."
-
-              # Create WSL config for better performance
-              $wslConfig = @"
-              [wsl2]
-              memory=6GB
-              processors=4
-              swap=2GB
-              localhostForwarding=true
-              "@
-              $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
-
-              # Restart WSL to apply config
-              wsl --shutdown
-              Start-Sleep -Seconds 3
-
-              Write-Host "WSL optimization complete - ready for engine build"
-
         - name: Cache Valkey build
           if: "${{ inputs.engine-version }}"
           uses: actions/cache@v4
@@ -128,12 +96,11 @@ runs:
                   valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
 
         - name: Install engine
-          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
-          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit == 'true' }}"
+          shell: bash
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit == 'true' && inputs.os != 'windows' }}"
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
-              WSLENV: ENGINE_VERSION:OS_TYPE
           run: |
               echo "Using cached Valkey binaries"
               echo "OS_TYPE: '$OS_TYPE'"
@@ -148,12 +115,11 @@ runs:
               sudo make install
 
         - name: Build engine from source
-          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
-          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit != 'true' }}"
+          shell: bash
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit != 'true' && inputs.os != 'windows' }}"
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
-              WSLENV: ENGINE_VERSION:OS_TYPE
           run: |
               echo "Building Valkey from source"
               echo "OS_TYPE: '$OS_TYPE'"
@@ -183,7 +149,6 @@ runs:
           if: "${{ inputs.engine-version }}"
           env:
               OS_TYPE: ${{ inputs.os }}
-              WSLENV: OS_TYPE
           run: |
               echo "Starting Valkey server"
               echo "OS_TYPE: '$OS_TYPE'"
diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index 5553ca542e..a6efff4650 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -113,7 +113,7 @@ tasks.register('startClusterForAz') {
             new ByteArrayOutputStream().withStream { os ->
                 exec {
                     workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
+                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
                     if (System.getProperty("tls") == 'true') args.add(2, '--tls')
                     commandLine args
                     standardOutput = os
diff --git a/java/integTest/src/test/java/glide/ConnectionTests.java b/java/integTest/src/test/java/glide/ConnectionTests.java
index 1600adac27..f3059f0e54 100644
--- a/java/integTest/src/test/java/glide/ConnectionTests.java
+++ b/java/integTest/src/test/java/glide/ConnectionTests.java
@@ -251,7 +251,7 @@ public void test_routing_with_az_affinity_strategy_to_1_replica() {
     public void test_az_affinity_non_existing_az() {
         assumeTrue(SERVER_VERSION.isGreaterThanOrEqualTo("8.0.0"), "Skip for versions below 8");
 
-        int nGetCalls = 3; // Match number of replicas
+        int nGetCalls = 4;
         int nReplicaCalls = 1;
         String getCmdstat = String.format("cmdstat_get:calls=%d", nReplicaCalls);
 
@@ -272,7 +272,7 @@ public void test_az_affinity_non_existing_az() {
         //  We expect the calls to be distributed evenly among the replicas
         long matchingEntries =
                 infoData.values().stream().filter(value -> value.contains(getCmdstat)).count();
-        assertEquals(3, matchingEntries); // 3 replicas (1 per shard) instead of 4
+        assertEquals(4, matchingEntries);
         azTestClient.close();
     }
 
diff --git a/java/integTest/src/test/java/glide/TestUtilities.java b/java/integTest/src/test/java/glide/TestUtilities.java
index 58be87620c..e1a2d8d0fd 100644
--- a/java/integTest/src/test/java/glide/TestUtilities.java
+++ b/java/integTest/src/test/java/glide/TestUtilities.java
@@ -19,7 +19,6 @@
 import glide.api.models.ClusterValue;
 import glide.api.models.GlideString;
 import glide.api.models.commands.InfoOptions.Section;
-import glide.api.models.configuration.AdvancedGlideClusterClientConfiguration;
 import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
@@ -194,15 +193,6 @@ public static <T> T[] concatenateArrays(T[]... arrays) {
             builder.address(
                     NodeAddress.builder().host(parts[0]).port(Integer.parseInt(parts[1])).build());
         }
-
-        // WSL-specific configuration to fix routing issues
-        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
-            builder.advancedConfiguration(
-                    AdvancedGlideClusterClientConfiguration.builder()
-                            .refreshTopologyFromInitialNodes(true)
-                            .build());
-        }
-
         return builder.useTLS(TLS);
     }
 
@@ -214,15 +204,6 @@ public static <T> T[] concatenateArrays(T[]... arrays) {
             builder.address(
                     NodeAddress.builder().host(parts[0]).port(Integer.parseInt(parts[1])).build());
         }
-
-        // WSL-specific configuration to fix routing issues
-        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
-            builder.advancedConfiguration(
-                    AdvancedGlideClusterClientConfiguration.builder()
-                            .refreshTopologyFromInitialNodes(true)
-                            .build());
-        }
-
         return builder.useTLS(TLS);
     }
 
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index ed05d37115..e5ea7ec51a 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -6,19 +6,13 @@
 import json
 import logging
 import os
-import platform
 import random
 import re
-import shutil
 import signal
 import socket
 import string
 import subprocess
 import time
-try:
-    import psutil  # type: ignore
-except ImportError:
-    psutil = None
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -44,9 +38,17 @@
 
 def get_command(commands: List[str]) -> str:
     for command in commands:
-        if shutil.which(command):
-            return command
-            
+        try:
+            result = subprocess.run(
+                ["which", command],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            if result.returncode == 0:
+                return command
+        except Exception as e:
+            logging.error(f"Error checking {command}: {e}")
     raise Exception(f"Neither {' nor '.join(commands)} found in the system.")
 
 
@@ -374,7 +376,6 @@ def get_server_version(server_name):
 
     # Define command arguments
     logfile = f"{node_folder}/server.log"
-    
     cmd_args = [
         get_server_command(),
         f"{'--tls-port' if tls else '--port'}",
@@ -447,8 +448,6 @@ def create_servers(
     logging.debug("## Creating servers")
     ready_servers: List[Server] = []
     nodes_count = shard_count * (1 + replica_count)
-    logging.info(f"DEBUG: create_servers called with shard_count={shard_count}, replica_count={replica_count}")
-    logging.info(f"DEBUG: Expected nodes_count = {shard_count} * (1 + {replica_count}) = {nodes_count}")
     tls_args = []
     if tls is True:
         if should_generate_new_tls_certs():
@@ -465,7 +464,7 @@ def create_servers(
             "--tls-auth-clients",  # Make it so client doesn't have to send cert
             "no",
             "--bind",
-            host,  # Bind to WSL IP for external access
+            host,
             "--port",
             "0",
         ]
@@ -473,7 +472,6 @@ def create_servers(
             tls_args.append("--tls-replication")
             tls_args.append("yes")
     servers_to_check = set()
-    logging.info(f"Starting {nodes_count} nodes (shard_count={shard_count}, replica_count={replica_count})")
     # Start all servers
     for i in range(nodes_count):
         port = ports[i] if ports else None
@@ -515,9 +513,6 @@ def create_servers(
     logging.debug("All servers are up!")
     toc = time.perf_counter()
     logging.debug(f"create_servers() Elapsed time: {toc - tic:0.4f}")
-    logging.info(f"DEBUG: create_servers returning {len(ready_servers)} servers (expected {nodes_count})")
-    for i, server in enumerate(ready_servers):
-        logging.info(f"DEBUG: Returning server {i+1}: {server.host}:{server.port}")
     return ready_servers
 
 
@@ -528,306 +523,30 @@ def create_cluster(
     cluster_folder: str,
     use_tls: bool,
 ):
-    logging.info(f"DEBUG: create_cluster() called with {len(servers)} servers")
-    for i, server in enumerate(servers):
-        logging.info(f"DEBUG: create_cluster() server {i+1}: {server.host}:{server.port}")
-    
     tic = time.perf_counter()
     servers_tuple = (str(server) for server in servers)
-    logging.info(f"Creating cluster with {len(servers)} servers: {list(str(s) for s in servers)}")
-    logging.info(f"Cluster replicas: {replica_count}")
-    
-    # Check cluster bus ports are accessible
-    logging.info("Checking cluster bus ports...")
-    for server in servers:
-        cluster_bus_port = server.port + 10000
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(1)
-            result = sock.connect_ex((server.host, cluster_bus_port))
-            if result == 0:
-                logging.info(f"Cluster bus port {server.host}:{cluster_bus_port} is accessible")
-            else:
-                logging.warning(f"Cluster bus port {server.host}:{cluster_bus_port} is not accessible (result: {result})")
-            sock.close()
-        except Exception as e:
-            logging.warning(f"Failed to check cluster bus port {server.host}:{cluster_bus_port}: {e}")
-    
     logging.debug("## Starting cluster creation...")
-    
-    cmd_args = [
-        get_cli_command(),
-        *get_cli_option_args(cluster_folder, use_tls),
-        "--cluster",
-        "create",
-        *servers_tuple,
-        "--cluster-replicas",
-        str(replica_count),
-        "--cluster-yes",
-    ]
-    logging.info(f"Executing cluster create command: {' '.join(cmd_args)}")
-    
     p = subprocess.Popen(
-        cmd_args,
+        [
+            get_cli_command(),
+            *get_cli_option_args(cluster_folder, use_tls),
+            "--cluster",
+            "create",
+            *servers_tuple,
+            "--cluster-replicas",
+            str(replica_count),
+            "--cluster-yes",
+        ],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         text=True,
     )
     output, err = p.communicate(timeout=40)
-    logging.info(f"Cluster create output: {output}")
-    if err:
-        logging.error(f"Cluster create error: {err}")
-    
-    # UNCONDITIONAL debugging - always check processes after cluster create
-    logging.info("=== IMMEDIATE PROCESS CHECK (ALWAYS RUNS) ===")
-    running_count = 0
-    for i, server in enumerate(servers):
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(0.5)  # Very quick check
-            result = sock.connect_ex((server.host, server.port))
-            sock.close()
-            if result == 0:
-                running_count += 1
-                logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
-            else:
-                logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
-        except Exception as e:
-            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - ERROR: {e}")
-    logging.info(f"IMMEDIATE STATUS: {running_count}/{len(servers)} servers responsive")
-    
-    # WSL NETWORKING DIAGNOSTICS (fast checks only)
-    if len(servers) > 6:  # Only run for high-replica clusters
-        logging.info("=== WSL NETWORKING DIAGNOSTICS ===")
-        
-        # 1. Cluster bus connectivity (sample only first 3 servers to save time)
-        logging.info("Testing cluster bus connectivity (sample)...")
-        for i in range(min(3, len(servers))):
-            server = servers[i]
-            cluster_bus_port = server.port + 10000
-            try:
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.settimeout(0.3)
-                result = sock.connect_ex((server.host, cluster_bus_port))
-                sock.close()
-                status = "ACCESSIBLE" if result == 0 else "NOT_ACCESSIBLE"
-                logging.info(f"Cluster bus {server.host}:{cluster_bus_port} - {status}")
-            except Exception as e:
-                logging.warning(f"Cluster bus {server.host}:{cluster_bus_port} - ERROR: {e}")
-        
-        # 2. Concurrent connection test (quick)
-        logging.info("Testing concurrent connections...")
-        open_sockets = []
-        max_concurrent = 0
-        for i, server in enumerate(servers):
-            try:
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.settimeout(0.2)
-                sock.connect((server.host, server.port))
-                open_sockets.append(sock)
-                max_concurrent = i + 1
-            except Exception as e:
-                logging.warning(f"Concurrent connection limit reached at {i+1}: {e}")
-                break
-        # Close all sockets
-        for sock in open_sockets:
-            try:
-                sock.close()
-            except:
-                pass
-        logging.info(f"Max concurrent connections: {max_concurrent}/{len(servers)}")
-        
-        # 3. WSL resource check (if psutil available)
-        if psutil is not None:
-            try:
-                mem = psutil.virtual_memory()
-                logging.info(f"WSL Memory: {mem.percent:.1f}% used ({mem.available // (1024*1024)} MB available)")
-                logging.info(f"WSL Process count: {len(psutil.pids())}")
-            except Exception as e:
-                logging.warning(f"Resource check failed: {e}")
-        
-        # WSL NETWORKING DIAGNOSTICS (fast checks only)
-        if len(servers) > 6:  # Only run for high-replica clusters
-            logging.info("=== WSL NETWORKING DIAGNOSTICS ===")
-            
-            # 1. Detailed cluster nodes analysis
-            logging.info("Analyzing cluster topology...")
-            try:
-                cluster_nodes_output = redis_cli_run_command([
-                    get_cli_command(), "-h", servers[0].host, "-p", str(servers[0].port),
-                    "cluster", "nodes"
-                ])
-                if cluster_nodes_output:
-                    lines = cluster_nodes_output.strip().split('\n')
-                    logging.info(f"CLUSTER NODES returned {len(lines)} lines:")
-                    for i, line in enumerate(lines):
-                        if line.strip():
-                            # Parse node info: node_id host:port@cluster_port flags master/slave
-                            parts = line.split()
-                            if len(parts) >= 3:
-                                node_id = parts[0][:8]  # First 8 chars of node ID
-                                host_port = parts[1].split('@')[0]  # Remove cluster port
-                                flags = parts[2]
-                                logging.info(f"  Node {i+1}: {host_port} ({flags}) ID:{node_id}")
-                            else:
-                                logging.info(f"  Node {i+1}: {line.strip()}")
-                else:
-                    logging.warning("CLUSTER NODES returned no output")
-                    
-                # Also check CLUSTER SLOTS which is what Java client uses for routing
-                cluster_slots_output = redis_cli_run_command([
-                    get_cli_command(), "-h", servers[0].host, "-p", str(servers[0].port),
-                    "cluster", "slots"
-                ])
-                if cluster_slots_output:
-                    logging.info("CLUSTER SLOTS output:")
-                    logging.info(cluster_slots_output)
-                else:
-                    logging.warning("CLUSTER SLOTS returned no output - THIS IS THE ROUTING PROBLEM")
-                    
-            except Exception as e:
-                logging.error(f"Failed to get cluster topology: {e}")
-            
-            # 2. Check cluster info from multiple nodes
-            logging.info("Checking cluster info from different nodes...")
-            for i in range(min(3, len(servers))):
-                server = servers[i]
-                try:
-                    cluster_info = redis_cli_run_command([
-                        get_cli_command(), "-h", server.host, "-p", str(server.port),
-                        "cluster", "info"
-                    ])
-                    if cluster_info and "cluster_known_nodes:" in cluster_info:
-                        known_nodes = [line for line in cluster_info.split('\n') if 'cluster_known_nodes:' in line]
-                        if known_nodes:
-                            logging.info(f"  Server {server.host}:{server.port} sees: {known_nodes[0]}")
-                except Exception as e:
-                    logging.warning(f"  Server {server.host}:{server.port} cluster info failed: {e}")
-            
-            # 3. Individual server health (ping test - very fast) - FIXED: Remove --connect-timeout
-            logging.info("Testing individual server health...")
-            healthy_servers = 0
-            for i, server in enumerate(servers[:5]):  # Test first 5 only to save time
-                try:
-                    ping_result: Optional[str] = redis_cli_run_command([
-                        get_cli_command(), "-h", server.host, "-p", str(server.port), 
-                        "ping"  # Removed --connect-timeout which caused the error
-                    ])
-                    if ping_result is not None and "PONG" in ping_result:
-                        healthy_servers += 1
-                        logging.info(f"Server {i+1} health: OK")
-                    else:
-                        logging.warning(f"Server {i+1} health: NO PONG")
-                except Exception as e:
-                    logging.warning(f"Server {i+1} health: ERROR - {e}")
-            logging.info(f"Healthy servers (sample): {healthy_servers}/5")
-            logging.info("=== END WSL DIAGNOSTICS ===")
-    
-    logging.info("=== END IMMEDIATE CHECK ===")
-    
-    # IMMEDIATE debugging - check processes right after cluster create, before any waiting
-    if replica_count > 0:
-        logging.info("=== REPLICA-SPECIFIC CHECK ===")
-        logging.info(f"Expected: {len(servers)} total servers ({len(servers) // (1 + replica_count)} masters + {len(servers) - len(servers) // (1 + replica_count)} replicas)")
-        logging.info("=== END REPLICA CHECK ===")
-    
-    # Parse the output to see what happened
-    if ">>> Performing hash slots allocation on" in output:
-        logging.info("Cluster create command started slot allocation")
-    if ">>> Nodes configuration updated" in output:
-        logging.info("Cluster nodes configuration was updated")
-    if ">>> Assign a different config epoch to each node" in output:
-        logging.info("Config epochs assigned to nodes")
-    if ">>> Sending CLUSTER MEET messages to join the cluster" in output:
-        logging.info("CLUSTER MEET messages sent")
-    if "Waiting for the cluster to join" in output:
-        logging.info("Waiting for cluster to join...")
-    if ">>> Performing Cluster Check" in output:
-        logging.info("Performing cluster check")
-        
     if err or "[OK] All 16384 slots covered." not in output:
         raise Exception(f"Failed to create cluster: {err if err else output}")
 
-    # Check server processes immediately after cluster creation, before waiting for topology
-    if replica_count > 0:
-        logging.info("=== CHECKING SERVER PROCESSES AFTER CLUSTER CREATE ===")
-        running_servers = 0
-        dead_servers = 0
-        for i, server in enumerate(servers):
-            try:
-                # Check if process is still running
-                if psutil is not None:
-                    if psutil.pid_exists(server.pid):
-                        proc = psutil.Process(server.pid)
-                        if proc.is_running() and proc.status() != psutil.STATUS_ZOMBIE:
-                            running_servers += 1
-                            logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - RUNNING")
-                        else:
-                            dead_servers += 1
-                            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - ZOMBIE/DEAD")
-                    else:
-                        dead_servers += 1
-                        logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - PROCESS NOT FOUND")
-                else:
-                    # Fallback: try to connect to the port to see if server is responsive
-                    try:
-                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                        sock.settimeout(1)
-                        result = sock.connect_ex((server.host, server.port))
-                        sock.close()
-                        if result == 0:
-                            running_servers += 1
-                            logging.info(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - RESPONSIVE")
-                        else:
-                            dead_servers += 1
-                            logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - NOT RESPONSIVE")
-                    except Exception as e:
-                        dead_servers += 1
-                        logging.warning(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} - CONNECTION ERROR: {e}")
-            except Exception as e:
-                dead_servers += 1
-                logging.error(f"Server {i+1}/{len(servers)}: {server.host}:{server.port} (PID {server.pid}) - ERROR: {e}")
-        
-        logging.info(f"Process status after cluster create: {running_servers} running, {dead_servers} dead/missing")
-        logging.info("=== END PROCESS CHECK ===")
-
     wait_for_a_message_in_logs(cluster_folder, "Cluster state changed: ok")
-    wait_for_all_topology_views(servers, cluster_folder, use_tls, replica_count)
-    
-    # Only do detailed replica verification if we have replicas and are in a slow environment
-    if replica_count > 0:
-        logging.info("Verifying replica synchronization...")
-        
-        # Quick check - just verify we can see all nodes in cluster
-        cmd_args = [
-            get_cli_command(),
-            "-h",
-            servers[0].host,
-            "-p", 
-            str(servers[0].port),
-            *get_cli_option_args(cluster_folder, use_tls),
-            "cluster",
-            "nodes",
-        ]
-        cluster_output: Optional[str] = redis_cli_run_command(cmd_args)
-        if cluster_output is not None:
-            connected_nodes = len([line for line in cluster_output.strip().split('\n') if 'connected' in line])
-            logging.info(f"Found {connected_nodes}/{len(servers)} connected nodes in cluster")
-            
-            # Show detailed node status
-            logging.info("=== CLUSTER NODES STATUS ===")
-            for line in cluster_output.strip().split('\n'):
-                if 'master' in line:
-                    logging.info(f"MASTER: {line}")
-                elif 'slave' in line:
-                    status = "CONNECTED" if 'connected' in line else "DISCONNECTED"
-                    logging.info(f"REPLICA ({status}): {line}")
-            logging.info("=== END CLUSTER STATUS ===")
-            
-            if connected_nodes != len(servers):
-                logging.warning(f"Not all nodes are connected! Expected {len(servers)}, found {connected_nodes}")
-        else:
-            logging.warning("Could not verify cluster node status")
+    wait_for_all_topology_views(servers, cluster_folder, use_tls)
     print_servers_json(servers)
 
     logging.debug("The cluster was successfully created!")
@@ -948,18 +667,16 @@ def redis_cli_run_command(cmd_args: List[str]) -> Optional[str]:
         )
         output, err = p.communicate(timeout=5)
         if err:
-            logging.error(f"CLI command failed: {' '.join(cmd_args[:3])}... - Error: {err}")
             raise Exception(
                 f"Failed to execute command: {str(p.args)}\n Return code: {p.returncode}\n Error: {err}"
             )
         return output
     except subprocess.TimeoutExpired:
-        logging.error(f"CLI command timed out: {' '.join(cmd_args[:3])}...")
         return None
 
 
 def wait_for_all_topology_views(
-    servers: List[Server], cluster_folder: str, use_tls: bool, replica_count: int = 0
+    servers: List[Server], cluster_folder: str, use_tls: bool
 ):
     """
     Wait for each of the nodes to have a topology view that contains all nodes.
@@ -977,52 +694,29 @@ def wait_for_all_topology_views(
             "slots",
         ]
         logging.debug(f"Executing: {cmd_args}")
-        
-        # Detect WSL environment and adjust behavior
-        is_wsl = os.path.exists('/proc/version') and 'microsoft' in open('/proc/version').read().lower()
-        retries = 320 if is_wsl else 160  # Double timeout for WSL
-        
+        retries = 80
         while retries >= 0:
             output = redis_cli_run_command(cmd_args)
-            if output is not None:
-                host_count = output.count(f"{server.host}")
-                expected_count = len(servers)
-                
-                # WSL-specific: Accept when we see all masters (replicas may not appear in CLUSTER SLOTS)
-                if is_wsl and replica_count > 0:
-                    master_count = len(servers) // (1 + replica_count)
-                    if host_count >= master_count:
-                        logging.info(f"WSL: Found {host_count} nodes (expected masters: {master_count}), continuing...")
-                        expected_count = host_count  # Accept current count for WSL
-                
-                if host_count == expected_count:
-                    # Server is ready, get the node's role
-                    cmd_args = [
-                        get_cli_command(),
-                        "-h",
-                        server.host,
-                        "-p",
-                        str(server.port),
-                        *get_cli_option_args(cluster_folder, use_tls),
-                        "cluster",
-                        "nodes",
-                    ]
-                    cluster_slots_output = redis_cli_run_command(cmd_args)
-                    node_info = parse_cluster_nodes(cluster_slots_output)
-                    if node_info:
-                        server.set_primary(node_info["is_primary"])
-                    logging.debug(f"Server {server} is ready!")
-                    break
-                else:
-                    if retries % 40 == 0:  # Log every 40 retries to avoid spam
-                        logging.info(f"Waiting for {server.host}:{server.port} - found {host_count}/{len(servers)} nodes")
-                    retries -= 1
-                    time.sleep(1)
-                    continue
+            if output is not None and output.count(f"{server.host}") == len(servers):
+                # Server is ready, get the node's role
+                cmd_args = [
+                    get_cli_command(),
+                    "-h",
+                    server.host,
+                    "-p",
+                    str(server.port),
+                    *get_cli_option_args(cluster_folder, use_tls),
+                    "cluster",
+                    "nodes",
+                ]
+                cluster_slots_output = redis_cli_run_command(cmd_args)
+                node_info = parse_cluster_nodes(cluster_slots_output)
+                if node_info:
+                    server.set_primary(node_info["is_primary"])
+                logging.debug(f"Server {server} is ready!")
+                break
             else:
                 retries -= 1
-                if retries == 0:
-                    logging.error(f"Topology wait failed for {server.host}:{server.port} - no CLI output received")
                 time.sleep(1)
                 continue
 
@@ -1336,6 +1030,15 @@ def stop_cluster(
 
 def main():
     parser = argparse.ArgumentParser(description="Cluster manager tool")
+    parser.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        help="Host address (default: %(default)s)",
+        required=False,
+        default="127.0.0.1",
+    )
+
     parser.add_argument(
         "--tls",
         default=False,
@@ -1430,15 +1133,6 @@ def main():
         required=False,
     )
 
-    parser_start.add_argument(
-        "-H",
-        "--host",
-        type=str,
-        help="Host address (default: %(default)s)",
-        required=False,
-        default="127.0.0.1",
-    )
-
     # Stop parser
     parser_stop = subparsers.add_parser("stop", help="Shutdown a running cluster")
     parser_stop.add_argument(
@@ -1478,15 +1172,6 @@ def main():
         default="",
     )
 
-    parser_stop.add_argument(
-        "-H",
-        "--host",
-        type=str,
-        help="Host address (default: %(default)s)",
-        required=False,
-        default="127.0.0.1",
-    )
-
     args = parser.parse_args()
     # Check logging level
 

From dd6b93e0aa91258fd3a22ee36b6ae007bfd8769b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:08:41 -0700
Subject: [PATCH 090/106] Add use of self-hosted external Valkey cluster and
 Windows runner

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/json_matrices/build-matrix.json       |  11 +
 .../workflows/create-test-matrices/action.yml |  13 +
 .../install-shared-dependencies/action.yml    | 105 +++-
 .github/workflows/java-self-hosted.yml        |  77 +++
 .../workflows/java-windows-self-hosted.yml    | 121 ++++
 .github/workflows/java.yml                    |  92 ++-
 .github/workflows/java.yml.bak                | 524 ++++++++++++++++++
 .github/workflows/setup-linux-runner.yml      | 145 +++++
 docs/REMOTE_CLUSTER_CREDENTIALS.md            | 245 ++++++++
 docs/REMOTE_CLUSTER_SETUP.md                  | 180 ++++++
 docs/VPC_MULTI_ENGINE_SETUP.md                | 252 +++++++++
 docs/VPC_SETUP_GUIDE.md                       | 182 ++++++
 java/integTest/build.gradle                   | 130 ++++-
 utils/multi_engine_manager.py                 | 469 ++++++++++++++++
 utils/remote_cluster_manager.py               | 359 ++++++++++++
 utils/setup_linux_runner.sh                   |  86 +++
 utils/setup_vpc_instance.sh                   | 150 +++++
 utils/setup_vpc_pair.sh                       |  47 ++
 utils/test_vpc_connectivity.py                | 202 +++++++
 19 files changed, 3364 insertions(+), 26 deletions(-)
 create mode 100644 .github/workflows/java-self-hosted.yml
 create mode 100644 .github/workflows/java-windows-self-hosted.yml
 create mode 100644 .github/workflows/java.yml.bak
 create mode 100644 .github/workflows/setup-linux-runner.yml
 create mode 100644 docs/REMOTE_CLUSTER_CREDENTIALS.md
 create mode 100644 docs/REMOTE_CLUSTER_SETUP.md
 create mode 100644 docs/VPC_MULTI_ENGINE_SETUP.md
 create mode 100644 docs/VPC_SETUP_GUIDE.md
 create mode 100755 utils/multi_engine_manager.py
 create mode 100755 utils/remote_cluster_manager.py
 create mode 100755 utils/setup_linux_runner.sh
 create mode 100755 utils/setup_vpc_instance.sh
 create mode 100755 utils/setup_vpc_pair.sh
 create mode 100755 utils/test_vpc_connectivity.py

diff --git a/.github/json_matrices/build-matrix.json b/.github/json_matrices/build-matrix.json
index da073a96c9..b39b028344 100644
--- a/.github/json_matrices/build-matrix.json
+++ b/.github/json_matrices/build-matrix.json
@@ -91,5 +91,16 @@
         "PACKAGE_MANAGERS": ["maven"],
         "languages": ["java"],
         "run": "always"
+    },
+    {
+        "OS": "windows",
+        "NAMED_OS": "windows",
+        "RUNNER": ["self-hosted", "windows", "x64"],
+        "ARCH": "x64",
+        "TARGET": "x86_64-pc-windows-msvc",
+        "PACKAGE_MANAGERS": ["maven"],
+        "languages": ["java"],
+        "run": "self-hosted-only",
+        "comment": "Self-hosted Windows runner for Java tests with remote Valkey cluster"
     }
 ]
diff --git a/.github/workflows/create-test-matrices/action.yml b/.github/workflows/create-test-matrices/action.yml
index 35d14a3075..1cc9aa9bd0 100644
--- a/.github/workflows/create-test-matrices/action.yml
+++ b/.github/workflows/create-test-matrices/action.yml
@@ -20,6 +20,10 @@ inputs:
             - use-self-hosted
             - use-github
         default: false
+    run-with-windows-self-hosted:
+        description: "Include self-hosted Windows runners"
+        type: boolean
+        default: false
     containers:
         description: "Run in containers"
         required: true
@@ -46,12 +50,14 @@ runs:
               EVENT_NAME: ${{ github.event_name }}
               RUN_FULL_MATRIX: ${{ inputs.run-full-matrix }}
               RUN_WITH_MACOS: ${{ inputs.run-with-macos }}
+              RUN_WITH_WINDOWS_SELF_HOSTED: ${{ inputs.run-with-windows-self-hosted }}
               CONTAINERS: ${{ inputs.containers }}
               LANGUAGE_NAME: ${{ inputs.language-name }}
           run: |
               echo "EVENT_NAME=$EVENT_NAME" >> $GITHUB_ENV
               echo "RUN_FULL_MATRIX=$RUN_FULL_MATRIX" >> $GITHUB_ENV
               echo "RUN_WITH_MACOS=$RUN_WITH_MACOS" >> $GITHUB_ENV
+              echo "RUN_WITH_WINDOWS_SELF_HOSTED=$RUN_WITH_WINDOWS_SELF_HOSTED" >> $GITHUB_ENV
               echo "CONTAINERS=$CONTAINERS" >> $GITHUB_ENV
               echo "LANGUAGE_NAME=$LANGUAGE_NAME" >> $GITHUB_ENV
 
@@ -97,6 +103,13 @@ runs:
               else
                 FINAL_MATRIX="$BASE_MATRIX"
               fi
+
+              # Add Windows self-hosted runners if specified
+              if [[ "$RUN_WITH_WINDOWS_SELF_HOSTED" == "true" ]]; then
+                echo "Including self-hosted Windows runners"
+                WIN_RUNNERS=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.languages? and any(.languages[] == $lang; .) and '"$CONDITION"' and .TARGET == "x86_64-pc-windows-msvc" and (.RUNNER == ["self-hosted","windows","x64"]))]' < .github/json_matrices/build-matrix.json)
+                FINAL_MATRIX=$(echo "$FINAL_MATRIX" "$WIN_RUNNERS" | jq -sc 'add')
+              fi
                         
               echo "host-matrix=$(echo $FINAL_MATRIX | tr -d '\n')" >> $GITHUB_OUTPUT
 
diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index a9367e2958..620e9c2779 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -68,13 +68,18 @@ runs:
           run: |
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
-        - name: Install software dependencies for Windows
+        - name: Verify Rust toolchain (Windows)
           shell: pwsh
           if: "${{ inputs.os == 'windows' }}"
           run: |
-              # Verify Rust toolchain is available
-              rustc --version
-              cargo --version
+              # Check if Rust is already available (may be pre-installed on self-hosted runners)
+              try {
+                  rustc --version
+                  cargo --version
+                  Write-Host "✅ Rust toolchain already available"
+              } catch {
+                  Write-Host "ℹ️ Rust toolchain not found - will be installed by install-rust-and-protoc action"
+              }
 
         - name: Setup Python for Windows
           if: "${{ inputs.os == 'windows' }}"
@@ -82,8 +87,94 @@ runs:
           with:
               python-version: "3.x"
 
+        - name: Check Windows build dependencies
+          if: "${{ inputs.os == 'windows' }}"
+          id: check-deps
+          shell: pwsh
+          run: |
+              Write-Host "Checking Windows build dependencies..."
+
+              # Check Python3
+              $python3Available = $false
+              try {
+                  python3 --version
+                  $python3Available = $true
+                  Write-Host "✅ Python3 already available"
+              } catch {
+                  try {
+                      python --version
+                      Write-Host "✅ Python available, will create python3 symlink"
+                      $python3Available = $true
+                  } catch {
+                      Write-Host "❌ Python not found"
+                  }
+              }
+
+              # Check Rust (should be installed by install-rust-and-protoc action)
+              $rustAvailable = $false
+              try {
+                  rustc --version
+                  cargo --version
+                  $rustAvailable = $true
+                  Write-Host "✅ Rust toolchain already available"
+              } catch {
+                  Write-Host "ℹ️ Rust toolchain will be installed by install-rust-and-protoc action"
+              }
+
+              # Check SSH client
+              $sshAvailable = $false
+              try {
+                  ssh -V 2>$null
+                  $sshAvailable = $true
+                  Write-Host "✅ SSH client available"
+              } catch {
+                  Write-Host "❌ SSH client not found"
+              }
+
+              # Set outputs for conditional steps
+              echo "python3-available=$python3Available" >> $env:GITHUB_OUTPUT
+              echo "rust-available=$rustAvailable" >> $env:GITHUB_OUTPUT
+              echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
+
+              Write-Host "Dependency check complete"
+
+        - name: Setup Python3 symlink (Windows)
+          if: "${{ inputs.os == 'windows' && steps.check-deps.outputs.python3-available == 'true' }}"
+          shell: pwsh
+          run: |
+              # Create python3 symlink if python exists but python3 doesn't
+              if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
+                  if (Get-Command python -ErrorAction SilentlyContinue) {
+                      Write-Host "Creating python3 symlink..."
+                      $pythonPath = (Get-Command python).Source
+                      $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
+                      New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
+                      Write-Host "✅ python3 symlink created"
+                  }
+              }
+
+        - name: Verify Windows dependencies for remote cluster mode
+          if: "${{ inputs.os == 'windows' }}"
+          shell: pwsh
+          run: |
+              Write-Host "Verifying Windows dependencies for remote cluster + build..."
+
+              # Verify Python3 (required for remote_cluster_manager.py)
+              python3 --version
+              Write-Host "✅ Python3 ready"
+
+              # Verify SSH (required for remote cluster access)
+              ssh -V
+              Write-Host "✅ SSH client ready"
+
+              # Note: Rust and protoc will be installed by subsequent actions
+              Write-Host "ℹ️ Rust toolchain and protoc will be installed by install-rust-and-protoc action"
+              Write-Host "ℹ️ JDK will be installed by setup-java action"
+
+              Write-Host "✅ Windows ready for Java client build + remote cluster testing"
+
         - name: Cache Valkey build
-          if: "${{ inputs.engine-version }}"
+          if: "${{ inputs.engine-version != '' }}"
           uses: actions/cache@v4
           id: cache-valkey
           with:
@@ -97,7 +188,7 @@ runs:
 
         - name: Install engine
           shell: bash
-          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit == 'true' && inputs.os != 'windows' }}"
+          if: "${{ inputs.engine-version != '' && steps.cache-valkey.outputs.cache-hit == 'true' && inputs.os != 'windows' }}"
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
@@ -116,7 +207,7 @@ runs:
 
         - name: Build engine from source
           shell: bash
-          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit != 'true' && inputs.os != 'windows' }}"
+          if: "${{ inputs.engine-version != '' && steps.cache-valkey.outputs.cache-hit != 'true' && inputs.os != 'windows' }}"
           env:
               ENGINE_VERSION: ${{ inputs.engine-version }}
               OS_TYPE: ${{ inputs.os }}
diff --git a/.github/workflows/java-self-hosted.yml b/.github/workflows/java-self-hosted.yml
new file mode 100644
index 0000000000..f2d230f7bd
--- /dev/null
+++ b/.github/workflows/java-self-hosted.yml
@@ -0,0 +1,77 @@
+name: Java Tests (Self-Hosted)
+
+on:
+    workflow_dispatch:
+        inputs:
+            java-version:
+                description: "Java version to test"
+                required: false
+                default: "17"
+                type: choice
+                options:
+                    - "11"
+                    - "17"
+            engine-version:
+                description: "Valkey engine version"
+                required: false
+                default: "8.0.1"
+                type: string
+
+jobs:
+    test-self-hosted:
+        name: Java ${{ github.event.inputs.java-version }} on Self-Hosted Linux
+        runs-on: [self-hosted, linux, valkey-runner] # Target your labeled runner
+        timeout-minutes: 35
+
+        steps:
+            - name: Setup self-hosted runner access
+              run: sudo chown -R $USER:$USER ${{ github.workspace }}
+
+            - uses: actions/checkout@v4
+
+            - name: Set up JDK ${{ github.event.inputs.java-version }}
+              uses: actions/setup-java@v4
+              with:
+                  distribution: "temurin"
+                  java-version: ${{ github.event.inputs.java-version }}
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Install shared software dependencies
+              uses: ./.github/workflows/install-shared-dependencies
+              with:
+                  os: ubuntu
+                  target: x86_64-unknown-linux-gnu
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  engine-version: ${{ github.event.inputs.engine-version }}
+                  language: java
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.gradle/caches
+                      ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+                  restore-keys: |
+                      ${{ runner.os }}-gradle-
+
+            - name: Build Java client
+              working-directory: java
+              run: ./gradlew --build-cache --continue build -x javadoc
+
+            - name: Run integration tests
+              working-directory: java
+              run: ./gradlew --build-cache :integTest:test
+
+            - name: Upload test reports
+              uses: actions/upload-artifact@v4
+              if: always()
+              with:
+                  name: java-test-reports-self-hosted
+                  path: |
+                      java/client/build/reports/**
+                      java/integTest/build/reports/**
diff --git a/.github/workflows/java-windows-self-hosted.yml b/.github/workflows/java-windows-self-hosted.yml
new file mode 100644
index 0000000000..b76124c4ae
--- /dev/null
+++ b/.github/workflows/java-windows-self-hosted.yml
@@ -0,0 +1,121 @@
+name: Java Tests (Windows Self-Hosted)
+
+on:
+    workflow_dispatch:
+        inputs:
+            java-version:
+                description: "Java version to test"
+                required: false
+                default: "17"
+                type: choice
+                options:
+                    - "11"
+                    - "17"
+            use-remote-cluster:
+                description: "Use remote Linux cluster"
+                required: false
+                default: true
+                type: boolean
+
+jobs:
+    test-windows-self-hosted:
+        name: Java ${{ github.event.inputs.java-version }} on Windows Self-Hosted
+        runs-on: [self-hosted, windows, valkey-runner] # Target Windows runner
+        timeout-minutes: 45
+
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Set up JDK ${{ github.event.inputs.java-version }}
+              uses: actions/setup-java@v4
+              with:
+                  distribution: "temurin"
+                  java-version: ${{ github.event.inputs.java-version }}
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Install shared software dependencies
+              uses: ./.github/workflows/install-shared-dependencies
+              with:
+                  os: windows
+                  target: x86_64-pc-windows-msvc
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  engine-version: "" # Skip Valkey installation on Windows
+                  language: java
+
+            - name: Configure remote Valkey cluster
+              if: ${{ github.event.inputs.use-remote-cluster == 'true' }}
+              shell: bash
+              run: |
+                  # Test if remote cluster is configured
+                  if [ -z "${{ vars.VALKEY_REMOTE_HOST }}" ]; then
+                      echo "⚠️ VALKEY_REMOTE_HOST not configured - will use local cluster"
+                      exit 0
+                  fi
+
+                  echo "🔧 Configuring remote Valkey cluster access..."
+
+                  # Set up SSH key from GitHub secret
+                  mkdir -p ~/.ssh
+                  chmod 700 ~/.ssh
+
+                  # Write SSH key content to file
+                  echo "${{ secrets.VALKEY_RUNNER_SSH_KEY }}" > ~/.ssh/valkey_runner_key
+                  chmod 600 ~/.ssh/valkey_runner_key
+
+                  # Configure SSH client
+                  cat >> ~/.ssh/config << EOF
+                  Host valkey-runner
+                      HostName ${{ vars.VALKEY_REMOTE_HOST }}
+                      User ubuntu
+                      IdentityFile ~/.ssh/valkey_runner_key
+                      StrictHostKeyChecking no
+                      UserKnownHostsFile /dev/null
+                      LogLevel ERROR
+                  EOF
+                  chmod 600 ~/.ssh/config
+
+                  # Test SSH connection
+                  echo "🔍 Testing SSH connection..."
+                  python3 utils/remote_cluster_manager.py test || {
+                      echo "❌ SSH connection test failed"
+                      exit 1
+                  }
+
+                  echo "✅ Remote cluster access configured successfully"
+
+                  # Set environment variables for Gradle
+                  echo "VALKEY_REMOTE_HOST=${{ vars.VALKEY_REMOTE_HOST }}" >> $GITHUB_ENV
+                  echo "SSH_PRIVATE_KEY_CONTENT=${{ secrets.VALKEY_RUNNER_SSH_KEY }}" >> $GITHUB_ENV
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.gradle/caches
+                      ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+                  restore-keys: |
+                      ${{ runner.os }}-gradle-
+
+            - name: Build Java client
+              working-directory: java
+              shell: bash
+              run: ./gradlew.bat --build-cache --continue build -x javadoc
+
+            - name: Run integration tests
+              working-directory: java
+              shell: bash
+              run: ./gradlew.bat --build-cache :integTest:test
+
+            - name: Upload test reports
+              uses: actions/upload-artifact@v4
+              if: always()
+              with:
+                  name: java-test-reports-windows-self-hosted
+                  path: |
+                      java/client/build/reports/**
+                      java/integTest/build/reports/**
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 47146b7576..a8970ed241 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -50,6 +50,10 @@ on:
                     - use-self-hosted
                     - use-github
                 default: false
+            use-windows-self-hosted:
+                description: "Use self-hosted Windows runner"
+                type: boolean
+                default: false
             name:
                 required: false
                 type: string
@@ -90,6 +94,8 @@ jobs:
                   # Run full test matrix if job started by cron or it was explictly specified by a person who triggered the workflow
                   run-full-matrix: ${{ github.event.inputs.full-matrix == 'true' || github.event_name == 'schedule' }}
                   run-with-macos: ${{ (github.event.inputs.run-with-macos) }}
+                  # Use Windows self-hosted runner with VPC Linux instance by default for code changes
+                  run-with-windows-self-hosted: ${{ github.event.inputs.use-windows-self-hosted == 'true' || github.event_name == 'push' || github.event_name == 'pull_request' }}
 
     test-java:
         name: Java Tests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
@@ -125,7 +131,7 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
-                  engine-version: ${{ matrix.engine.version }}
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
                   language: java
 
             - name: Install protoc (protobuf)
@@ -161,6 +167,86 @@ jobs:
                   # Create python3 symlink for Windows
                   ln -sf $(which python) /usr/bin/python3
 
+            - name: Configure VPC/Remote Valkey instance (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: bash
+              run: |
+                  # Check configuration priority: VPC > Remote > Local
+                  if [ -n "${{ vars.VALKEY_VPC_HOST }}" ]; then
+                      echo "🔧 Configuring VPC Valkey instance access..."
+                      
+                      # Set up SSH key from GitHub secret
+                      mkdir -p ~/.ssh
+                      chmod 700 ~/.ssh
+                      
+                      # Write SSH key content to file
+                      echo "${{ secrets.VALKEY_VPC_SSH_KEY }}" > ~/.ssh/valkey_vpc_key
+                      chmod 600 ~/.ssh/valkey_vpc_key
+                      
+                      # Configure SSH client for VPC
+                      cat >> ~/.ssh/config << EOF
+                  Host valkey-vpc
+                      HostName ${{ vars.VALKEY_VPC_HOST }}
+                      User ubuntu
+                      IdentityFile ~/.ssh/valkey_vpc_key
+                      StrictHostKeyChecking no
+                      UserKnownHostsFile /dev/null
+                      LogLevel ERROR
+                  EOF
+                      chmod 600 ~/.ssh/config
+                      
+                      # Test SSH connection
+                      echo "🔍 Testing VPC SSH connection..."
+                      ssh -i ~/.ssh/valkey_vpc_key ubuntu@${{ vars.VALKEY_VPC_HOST }} "echo 'VPC connection successful'" || {
+                          echo "❌ VPC SSH connection failed"
+                          exit 1
+                      }
+                      
+                      echo "✅ VPC Valkey instance configured successfully"
+                      
+                      # Set environment variables for Gradle
+                      echo "VALKEY_VPC_HOST=${{ vars.VALKEY_VPC_HOST }}" >> $GITHUB_ENV
+                      echo "SSH_PRIVATE_KEY_CONTENT=${{ secrets.VALKEY_VPC_SSH_KEY }}" >> $GITHUB_ENV
+                      
+                  elif [ -n "${{ vars.VALKEY_REMOTE_HOST }}" ]; then
+                      echo "🔧 Configuring remote Valkey cluster access..."
+                      
+                      # Set up SSH key from GitHub secret
+                      mkdir -p ~/.ssh
+                      chmod 700 ~/.ssh
+                      
+                      # Write SSH key content to file
+                      echo "${{ secrets.VALKEY_RUNNER_SSH_KEY }}" > ~/.ssh/valkey_runner_key
+                      chmod 600 ~/.ssh/valkey_runner_key
+                      
+                      # Configure SSH client
+                      cat >> ~/.ssh/config << EOF
+                  Host valkey-runner
+                      HostName ${{ vars.VALKEY_REMOTE_HOST }}
+                      User ubuntu
+                      IdentityFile ~/.ssh/valkey_runner_key
+                      StrictHostKeyChecking no
+                      UserKnownHostsFile /dev/null
+                      LogLevel ERROR
+                  EOF
+                      chmod 600 ~/.ssh/config
+                      
+                      # Test SSH connection
+                      echo "🔍 Testing SSH connection..."
+                      python3 utils/remote_cluster_manager.py test || {
+                          echo "❌ SSH connection test failed"
+                          exit 1
+                      }
+                      
+                      echo "✅ Remote cluster access configured successfully"
+                      
+                      # Set environment variables for Gradle
+                      echo "VALKEY_REMOTE_HOST=${{ vars.VALKEY_REMOTE_HOST }}" >> $GITHUB_ENV
+                      echo "SSH_PRIVATE_KEY_CONTENT=${{ secrets.VALKEY_RUNNER_SSH_KEY }}" >> $GITHUB_ENV
+                  else
+                      echo "⚠️ No VPC or remote cluster configured - will use local cluster"
+                  fi
+
             - name: Build java client
               working-directory: java
               env:
@@ -233,7 +319,7 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
-                  engine-version: ${{ matrix.engine.version }}
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
                   language: java
 
             - name: Install protoc (protobuf)
@@ -372,7 +458,7 @@ jobs:
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
                   language: java
-                  engine-version: ${{ matrix.engine.version }}
+                  engine-version: ${{ matrix.host.OS == 'windows' && '' || matrix.engine.version }}
 
             - name: Install protoc (protobuf)
               uses: arduino/setup-protoc@v3
diff --git a/.github/workflows/java.yml.bak b/.github/workflows/java.yml.bak
new file mode 100644
index 0000000000..64f1afc2e4
--- /dev/null
+++ b/.github/workflows/java.yml.bak
@@ -0,0 +1,524 @@
+name: Java CI
+
+permissions:
+    contents: read
+
+on:
+    push:
+        branches:
+            - main
+            - release-*
+            - v*
+        paths:
+            - glide-core/src/**
+            - glide-core/redis-rs/redis/src/**
+            - java/**
+            - utils/cluster_manager.py
+            - .github/workflows/java.yml
+            - .github/workflows/install-shared-dependencies/action.yml
+            - .github/workflows/test-benchmark/action.yml
+            - .github/workflows/lint-rust/action.yml
+            - .github/workflows/install-engine/action.yml
+            - .github/workflows/create-test-matrices/action.yml
+            - .github/json_matrices/**
+
+    pull_request:
+        paths:
+            - glide-core/src/**
+            - glide-core/redis-rs/redis/src/**
+            - java/**
+            - utils/cluster_manager.py
+            - .github/workflows/java.yml
+            - .github/workflows/install-shared-dependencies/action.yml
+            - .github/workflows/test-benchmark/action.yml
+            - .github/workflows/lint-rust/action.yml
+            - .github/workflows/install-engine/action.yml
+            - .github/workflows/create-test-matrices/action.yml
+            - .github/json_matrices/**
+
+    workflow_dispatch:
+        inputs:
+            full-matrix:
+                description: "Run the full engine, host, and language version matrix"
+                type: boolean
+                default: false
+            run-with-macos:
+                description: "Run with macos included (only when necessary)"
+                type: choice
+                options:
+                    - false
+                    - use-self-hosted
+                    - use-github
+                default: false
+            name:
+                required: false
+                type: string
+                description: "(Optional) Test run name"
+            run-modules-tests:
+                description: "Run modules tests"
+                type: boolean
+                default: false
+
+    workflow_call:
+        inputs:
+            run-with-macos:
+                description: "Run with macos included (only when necessary)"
+                type: string
+                default: false
+
+concurrency:
+    group: java-${{ github.head_ref || github.ref }}-${{ toJson(inputs) }}
+    cancel-in-progress: true
+
+run-name:
+    # Set custom name if job is started manually and name is given
+    ${{ github.event_name == 'workflow_dispatch' && (inputs.name == '' && format('{0} @ {1} {2}', github.ref_name, github.sha, toJson(inputs)) || inputs.name) || '' }}
+
+jobs:
+    get-matrices:
+        runs-on: ubuntu-latest
+        outputs:
+            engine-matrix-output: ${{ steps.get-matrices.outputs.engine-matrix-output }}
+            host-matrix-output: ${{ steps.get-matrices.outputs.host-matrix-output }}
+            version-matrix-output: ${{ steps.get-matrices.outputs.version-matrix-output }}
+        steps:
+            - uses: actions/checkout@v4
+            - id: get-matrices
+              uses: ./.github/workflows/create-test-matrices
+              with:
+                  language-name: java
+                  # Run full test matrix if job started by cron or it was explictly specified by a person who triggered the workflow
+                  run-full-matrix: ${{ github.event.inputs.full-matrix == 'true' || github.event_name == 'schedule' }}
+                  run-with-macos: ${{ (github.event.inputs.run-with-macos) }}
+
+    test-java:
+        name: Java Tests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
+        needs: get-matrices
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
+        strategy:
+            fail-fast: false
+            matrix:
+                java: ${{ fromJson(needs.get-matrices.outputs.version-matrix-output) }}
+                engine: ${{ fromJson(needs.get-matrices.outputs.engine-matrix-output) }}
+                host: ${{ fromJson(needs.get-matrices.outputs.host-matrix-output) }}
+        runs-on: ${{ matrix.host.RUNNER }}
+
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Output Matrix Parameters for this job
+              run: |
+                  echo "Job running with the following matrix configuration:"
+                  echo "${{ toJson(matrix) }}"
+
+            - uses: gradle/actions/wrapper-validation@v4
+
+            - name: Set up JDK ${{ matrix.java }}
+              uses: actions/setup-java@v4
+              with:
+                  distribution: "temurin"
+                  java-version: ${{ matrix.java }}
+
+            - name: Install shared software dependencies
+              uses: ./.github/workflows/install-shared-dependencies
+              with:
+                  os: ${{ matrix.host.OS }}
+                  target: ${{ matrix.host.TARGET }}
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  engine-version: ${{ matrix.engine.version }}
+                  language: java
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      java/target
+                      glide-core/src/generated
+                  key: ${{ matrix.host.TARGET }}-java
+                  restore-keys: |
+                      ${{ matrix.host.TARGET }}-glide-core
+                      ${{ matrix.host.TARGET }}
+
+            - name: Cache Gradle dependencies
+              uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.gradle/caches
+                      ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-${{ hashFiles('java/**/*.gradle*', 'java/**/gradle-wrapper.properties') }}
+                  restore-keys: |
+                      ${{ runner.os }}-gradle-
+
+            - name: Setup Python3 for Windows
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: bash
+              run: |
+                  # Create python3 symlink for Windows
+                  ln -sf $(which python) /usr/bin/python3
+
+            - name: Configure remote Valkey cluster (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: bash
+              run: |
+                  # Set up SSH key for remote cluster access
+                  mkdir -p ~/.ssh
+                  echo "${{ secrets.VALKEY_RUNNER_SSH_KEY }}" > ~/.ssh/valkey_runner_key
+                  chmod 600 ~/.ssh/valkey_runner_key
+                  
+                  # Configure SSH
+                  cat >> ~/.ssh/config << EOF
+                  Host valkey-runner
+                      HostName ${{ vars.VALKEY_REMOTE_HOST }}
+                      User ubuntu
+                      IdentityFile ~/.ssh/valkey_runner_key
+                      StrictHostKeyChecking no
+                  EOF
+                  
+                  # Set environment variable for remote cluster
+                  echo "VALKEY_REMOTE_HOST=${{ vars.VALKEY_REMOTE_HOST }}" >> $GITHUB_ENV
+                  echo "SSH_PRIVATE_KEY_PATH=~/.ssh/valkey_runner_key" >> $GITHUB_ENV
+
+            - name: Build java client
+              working-directory: java
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache --continue build -x javadoc
+                  else
+                      ./gradlew --build-cache --continue build -x javadoc
+                  fi
+
+            - name: Ensure no skipped files by linter
+              working-directory: java
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  else
+                      ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  fi
+
+            - uses: ./.github/workflows/test-benchmark
+              if: ${{ matrix.engine.version == '8.0' && matrix.host.RUNNER == 'ubuntu-latest' && matrix.java == '17' }}
+              with:
+                  language-flag: -java
+
+            - name: Upload test & spotbugs reports
+              if: always()
+              continue-on-error: true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: test-reports-java-${{ matrix.java }}-${{ matrix.engine.type }}-${{ matrix.engine.version }}-${{ matrix.host.RUNNER }}
+                  path: |
+                      java/client/build/reports/**
+                      java/integTest/build/reports/**
+                      utils/clusters/**
+                      benchmarks/results/**
+                      java/client/build/reports/spotbugs/**
+
+    test-pubsub:
+        name: Java PubSubTests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
+        needs: get-matrices
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
+        strategy:
+            fail-fast: false
+            matrix:
+                java: ${{ fromJson(needs.get-matrices.outputs.version-matrix-output) }}
+                engine: ${{ fromJson(needs.get-matrices.outputs.engine-matrix-output) }}
+                host: ${{ fromJson(needs.get-matrices.outputs.host-matrix-output) }}
+        runs-on: ${{ matrix.host.RUNNER }}
+
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Output Matrix Parameters for this job
+              run: |
+                  echo "Job running with the following matrix configuration:"
+                  echo "${{ toJson(matrix) }}"
+
+            - name: Set up JDK ${{ matrix.java }}
+              uses: actions/setup-java@v4
+              with:
+                  distribution: "temurin"
+                  java-version: ${{ matrix.java }}
+
+            - name: Install shared software dependencies
+              uses: ./.github/workflows/install-shared-dependencies
+              with:
+                  os: ${{ matrix.host.OS }}
+                  target: ${{ matrix.host.TARGET }}
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  engine-version: ${{ matrix.engine.version }}
+                  language: java
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      java/target
+                      glide-core/src/generated
+                  key: ${{ matrix.host.TARGET }}-java
+                  restore-keys: |
+                      ${{ matrix.host.TARGET }}-glide-core
+                      ${{ matrix.host.TARGET }}
+
+            - name: Cache Gradle dependencies
+              uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.gradle/caches
+                      ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-${{ hashFiles('java/**/*.gradle*', 'java/**/gradle-wrapper.properties') }}
+                  restore-keys: |
+                      ${{ runner.os }}-gradle-
+
+            - name: Setup networking and verify Valkey for PubSub (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: pwsh
+              run: |
+                  # Optimize WSL for better performance (PubSub tests)
+                  Write-Host "Optimizing WSL configuration for PubSub tests..."
+
+                  # Create WSL config for better performance
+                  $wslConfig = @"
+                  [wsl2]
+                  memory=6GB
+                  processors=4
+                  swap=2GB
+                  localhostForwarding=true
+                  "@
+                  $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+
+                  # Restart WSL to apply config
+                  wsl --shutdown
+                  Start-Sleep -Seconds 3
+
+                  Write-Host "WSL optimization complete"
+
+            - name: Test pubsub
+              working-directory: java
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache :integTest:pubsubTest
+                  else
+                      ./gradlew --build-cache :integTest:pubsubTest
+                  fi
+
+            - name: Upload test & spotbugs reports
+              if: always()
+              continue-on-error: true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: test-reports-pubsub-java-${{ matrix.java }}-${{ matrix.engine.type }}-${{ matrix.engine.version }}-${{ matrix.host.OS }}-${{ matrix.host.ARCH }}
+                  path: |
+                      java/integTest/build/reports/**
+                      utils/clusters/**
+
+    get-containers:
+        runs-on: ubuntu-latest
+        if: ${{ github.event.inputs.full-matrix == 'true' || github.event_name == 'schedule' }}
+        outputs:
+            engine-matrix-output: ${{ steps.get-matrices.outputs.engine-matrix-output }}
+            host-matrix-output: ${{ steps.get-matrices.outputs.host-matrix-output }}
+            version-matrix-output: ${{ steps.get-matrices.outputs.version-matrix-output }}
+
+        steps:
+            - uses: actions/checkout@v4
+            - id: get-matrices
+              uses: ./.github/workflows/create-test-matrices
+              with:
+                  language-name: java
+                  run-full-matrix: true
+                  containers: true
+
+    test-java-container:
+        runs-on: ${{ matrix.host.RUNNER }}
+        needs: [get-containers]
+        timeout-minutes: 25
+        strategy:
+            fail-fast: false
+            matrix:
+                java: ${{ fromJson(needs.get-containers.outputs.version-matrix-output) }}
+                engine: ${{ fromJson(needs.get-containers.outputs.engine-matrix-output) }}
+                host: ${{ fromJson(needs.get-containers.outputs.host-matrix-output) }}
+        container:
+            image: ${{ matrix.host.IMAGE }}
+            options: ${{ join(' -q ', matrix.host.CONTAINER_OPTIONS) }} # adding `-q` to bypass empty options
+        steps:
+            - name: Install git and Java
+              run: |
+                  # Set environment variable to indicate container environment for Gradle
+                  echo "GLIDE_CONTAINER_BUILD=true" >> $GITHUB_ENV
+                  if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
+                    yum update -y
+                    yum install -y git tar java-${{ matrix.java }}-amazon-corretto-devel.x86_64
+                    # Set JAVA_HOME to use the installed JDK
+                    export JAVA_HOME=/usr/lib/jvm/java-${{ matrix.java }}-amazon-corretto.x86_64
+                    echo "JAVA_HOME=/usr/lib/jvm/java-${{ matrix.java }}-amazon-corretto.x86_64" >> $GITHUB_ENV
+                    echo "/usr/lib/jvm/java-${{ matrix.java }}-amazon-corretto.x86_64/bin" >> $GITHUB_PATH
+                    # Create gradle user home and disable auto-download
+                    mkdir -p ~/.gradle
+                    echo "org.gradle.java.installations.auto-download=false" >> ~/.gradle/gradle.properties
+                    echo IMAGE=amazonlinux:latest | sed -r 's/:/-/g' >> $GITHUB_ENV
+                  elif [[ "${{ matrix.host.TARGET }}" == *"musl"* ]]; then
+                    apk add openjdk${{matrix.java}} git bash
+                    # Temporarily installing openjdk11 because of issue: https://github.com/valkey-io/valkey-glide/issues/4664
+                    apk add openjdk11
+                    export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-openjdk
+                    # Create gradle user home and disable auto-download
+                    mkdir -p ~/.gradle
+                    echo "org.gradle.java.installations.auto-download=false" >> ~/.gradle/gradle.properties
+                  fi
+            # Replace `:` in the variable otherwise it can't be used in `upload-artifact`
+            - uses: actions/checkout@v4
+              with:
+                  submodules: recursive
+
+            - name: Install shared software dependencies
+              uses: ./.github/workflows/install-shared-dependencies
+              with:
+                  os: ${{ matrix.host.OS }}
+                  target: ${{ matrix.host.TARGET }}
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  language: java
+                  engine-version: ${{ matrix.engine.version }}
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            # Ensure Rust is in PATH for container environments
+            - name: Setup Rust Build
+              if: ${{ contains(matrix.host.TARGET, 'musl') }}
+              run: |
+                  export PATH="$HOME/.cargo/bin:$PATH"
+                  echo "PATH=$HOME/.cargo/bin:$PATH" >> $GITHUB_ENV
+
+                  # Install ziglang and zigbuild
+                  pip3 install ziglang --break-system-packages
+                  cargo install --locked cargo-zigbuild
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      java/target
+                      glide-core/src/generated
+                  key: ${{ matrix.host.IMAGE }}-java
+                  restore-keys: ${{ matrix.host.IMAGE }}
+
+            - name: Cache Gradle dependencies
+              uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.gradle/caches
+                      ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-container-${{ hashFiles('java/**/*.gradle*', 'java/**/gradle-wrapper.properties') }}
+                  restore-keys: |
+                      ${{ runner.os }}-gradle-container-
+                      ${{ runner.os }}-gradle-
+
+            - name: Build java wrapper
+              working-directory: java
+              env:
+                  GLIDE_CONTAINER_BUILD: true
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
+                      export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-amazon-corretto.x86_64
+                  else
+                      # TODO: Fix java version. Java matrix tests are currently broken for all OS and Java 11 is always used.
+                      # On other OS, build auto-downloads Java 11 but this doesn't work on Alpine
+                      # https://github.com/valkey-io/valkey-glide/issues/4664
+                      # export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-openjdk
+                      export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
+                      export PATH=$HOME/.cargo/bin:$PATH
+                  fi
+                  ./gradlew --stacktrace --build-cache --continue build -x javadoc
+
+            - name: Upload test & spotbugs reports
+              if: always()
+              continue-on-error: true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: test-reports-java-${{ matrix.java }}-${{ matrix.engine.type }}-${{ matrix.engine.version }}-${{ env.IMAGE }}-${{ matrix.host.ARCH }}
+                  path: |
+                      java/client/build/reports/**
+                      java/integTest/build/reports/**
+                      java/client/build/reports/spotbugs/**
+
+    lint-rust:
+        timeout-minutes: 15
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: ./.github/workflows/lint-rust
+              with:
+                  cargo-toml-folder: java
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+              name: lint java rust
+
+    test-modules:
+        if: ((github.repository_owner == 'valkey-io' && github.event_name == 'workflow_dispatch' && github.event.inputs.run-modules-tests == 'true') || github.event.pull_request.head.repo.owner.login == 'valkey-io')
+        environment: AWS_ACTIONS
+        name: Modules Tests
+        runs-on: [self-hosted, linux, ARM64, persistent]
+        timeout-minutes: 15
+        steps:
+            - name: Setup self-hosted runner access
+              run: sudo chown -R $USER:$USER /home/ubuntu/actions-runner/_work/valkey-glide
+
+            - uses: actions/checkout@v4
+
+            - name: Set up JDK
+              uses: actions/setup-java@v4
+              with:
+                  distribution: "temurin"
+                  java-version: 17
+
+            - name: Install protoc (protobuf)
+              uses: arduino/setup-protoc@v3
+              with:
+                  version: "29.1"
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+            - uses: actions/cache@v4
+              with:
+                  path: |
+                      java/target
+                      glide-core/src/generated
+                  key: aarch64-unknown-linux-gnu-java
+                  restore-keys: |
+                      aarch64-unknown-linux-gnu-glide-core
+                      aarch64-unknown-linux-gnu
+
+            - name: Install zig
+              uses: ./.github/workflows/install-zig
+
+            - name: Test java wrapper
+              working-directory: java
+              run: ./gradlew :integTest:modulesTest -Dcluster-endpoints=${{ secrets.MEMDB_MODULES_ENDPOINT }} -Dtls=true
+
+            - name: Upload test reports
+              if: always()
+              continue-on-error: true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: test-reports-modules
+                  path: |
+                      java/integTest/build/reports/**
diff --git a/.github/workflows/setup-linux-runner.yml b/.github/workflows/setup-linux-runner.yml
new file mode 100644
index 0000000000..6a925910b1
--- /dev/null
+++ b/.github/workflows/setup-linux-runner.yml
@@ -0,0 +1,145 @@
+name: Setup Linux Runner for Valkey
+
+on:
+    workflow_dispatch:
+        inputs:
+            action:
+                description: "Action to perform"
+                required: true
+                default: "start"
+                type: choice
+                options:
+                    - start
+                    - stop
+                    - status
+            instance_type:
+                description: "EC2 instance type"
+                required: false
+                default: "t3.medium"
+                type: string
+
+jobs:
+    manage-linux-runner:
+        runs-on: ubuntu-latest
+        outputs:
+            runner-ip: ${{ steps.setup.outputs.runner-ip }}
+
+        steps:
+            - name: Configure AWS credentials
+              uses: aws-actions/configure-aws-credentials@v4
+              with:
+                  aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+                  aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+                  aws-region: us-east-1
+
+            - name: Setup Linux Runner
+              id: setup
+              run: |
+                  case "${{ github.event.inputs.action }}" in
+                    "start")
+                      echo "Starting Linux runner instance..."
+                      
+                      # Create security group if it doesn't exist
+                      aws ec2 describe-security-groups --group-names valkey-runner-sg || \
+                      aws ec2 create-security-group \
+                        --group-name valkey-runner-sg \
+                        --description "Security group for Valkey test runner" \
+                        --vpc-id $(aws ec2 describe-vpcs --filters "Name=is-default,Values=true" --query 'Vpcs[0].VpcId' --output text)
+                      
+                      # Add SSH and Valkey port rules
+                      aws ec2 authorize-security-group-ingress \
+                        --group-name valkey-runner-sg \
+                        --protocol tcp \
+                        --port 22 \
+                        --cidr 0.0.0.0/0 || true
+                      
+                      aws ec2 authorize-security-group-ingress \
+                        --group-name valkey-runner-sg \
+                        --protocol tcp \
+                        --port 6379-6400 \
+                        --cidr 0.0.0.0/0 || true
+                      
+                      # Launch instance
+                      INSTANCE_ID=$(aws ec2 run-instances \
+                        --image-id ami-0c02fb55956c7d316 \
+                        --instance-type ${{ github.event.inputs.instance_type }} \
+                        --key-name ${{ secrets.AWS_KEY_PAIR_NAME }} \
+                        --security-groups valkey-runner-sg \
+                        --user-data file://<(cat << 'EOF'
+                      #!/bin/bash
+                      apt-get update
+                      apt-get install -y python3 python3-pip git build-essential pkg-config libssl-dev
+                      
+                      # Install Valkey
+                      cd /tmp
+                      git clone https://github.com/valkey-io/valkey.git
+                      cd valkey
+                      make -j$(nproc) BUILD_TLS=yes
+                      make install
+                      
+                      # Setup GitHub Actions runner
+                      mkdir -p /home/ubuntu/actions-runner
+                      cd /home/ubuntu/actions-runner
+                      curl -o actions-runner-linux-x64-2.311.0.tar.gz -L https://github.com/actions/runner/releases/download/v2.311.0/actions-runner-linux-x64-2.311.0.tar.gz
+                      tar xzf ./actions-runner-linux-x64-2.311.0.tar.gz
+                      chown -R ubuntu:ubuntu /home/ubuntu/actions-runner
+                      
+                      # Configure runner (will be done manually or via API)
+                      echo "Runner setup complete"
+                      EOF
+                      ) \
+                        --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=valkey-runner},{Key=Purpose,Value=github-actions}]' \
+                        --query 'Instances[0].InstanceId' \
+                        --output text)
+                      
+                      echo "Instance ID: $INSTANCE_ID"
+                      echo "instance-id=$INSTANCE_ID" >> $GITHUB_OUTPUT
+                      
+                      # Wait for instance to be running
+                      aws ec2 wait instance-running --instance-ids $INSTANCE_ID
+                      
+                      # Get public IP
+                      PUBLIC_IP=$(aws ec2 describe-instances \
+                        --instance-ids $INSTANCE_ID \
+                        --query 'Reservations[0].Instances[0].PublicIpAddress' \
+                        --output text)
+                      
+                      echo "Runner IP: $PUBLIC_IP"
+                      echo "runner-ip=$PUBLIC_IP" >> $GITHUB_OUTPUT
+                      ;;
+                      
+                    "stop")
+                      echo "Stopping Linux runner instances..."
+                      INSTANCE_IDS=$(aws ec2 describe-instances \
+                        --filters "Name=tag:Purpose,Values=github-actions" "Name=instance-state-name,Values=running" \
+                        --query 'Reservations[].Instances[].InstanceId' \
+                        --output text)
+                      
+                      if [ -n "$INSTANCE_IDS" ]; then
+                        aws ec2 terminate-instances --instance-ids $INSTANCE_IDS
+                        echo "Terminated instances: $INSTANCE_IDS"
+                      else
+                        echo "No running instances found"
+                      fi
+                      ;;
+                      
+                    "status")
+                      echo "Checking Linux runner status..."
+                      aws ec2 describe-instances \
+                        --filters "Name=tag:Purpose,Values=github-actions" \
+                        --query 'Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress,InstanceType]' \
+                        --output table
+                      ;;
+                  esac
+
+            - name: Save runner info
+              if: github.event.inputs.action == 'start'
+              run: |
+                  echo "Linux runner started successfully!"
+                  echo "IP Address: ${{ steps.setup.outputs.runner-ip }}"
+                  echo ""
+                  echo "To use this runner in Windows tests, set environment variable:"
+                  echo "VALKEY_REMOTE_HOST=${{ steps.setup.outputs.runner-ip }}"
+                  echo ""
+                  echo "SSH access:"
+                  echo "ssh -i ~/.ssh/your-key.pem ubuntu@${{ steps.setup.outputs.runner-ip }}"
diff --git a/docs/REMOTE_CLUSTER_CREDENTIALS.md b/docs/REMOTE_CLUSTER_CREDENTIALS.md
new file mode 100644
index 0000000000..df55606ef6
--- /dev/null
+++ b/docs/REMOTE_CLUSTER_CREDENTIALS.md
@@ -0,0 +1,245 @@
+# Remote Cluster Credentials Setup
+
+This guide explains how to securely configure SSH credentials for remote Valkey cluster access.
+
+## Overview
+
+Windows runners connect to Linux runners via SSH to manage Valkey clusters. This requires secure credential management using GitHub secrets and variables.
+
+## Required Credentials
+
+### 1. SSH Key Pair
+
+**Generate SSH key pair:**
+```bash
+# Generate new key pair for Valkey runner
+ssh-keygen -t ed25519 -f ~/.ssh/valkey_runner_key -C "valkey-runner@github-actions"
+
+# Public key (add to Linux runner)
+cat ~/.ssh/valkey_runner_key.pub
+
+# Private key (add to GitHub secret)
+cat ~/.ssh/valkey_runner_key
+```
+
+### 2. GitHub Repository Configuration
+
+#### Secrets (Repository Settings → Secrets and variables → Actions)
+
+**Required Secrets:**
+```
+VALKEY_RUNNER_SSH_KEY
+├── Description: Private SSH key for remote cluster access
+├── Value: Contents of ~/.ssh/valkey_runner_key (entire file)
+└── Usage: Automatically injected into Windows workflows
+
+AWS_ACCESS_KEY_ID (optional - for EC2 management)
+├── Description: AWS access key for EC2 instance management
+└── Value: Your AWS access key
+
+AWS_SECRET_ACCESS_KEY (optional - for EC2 management)  
+├── Description: AWS secret key for EC2 instance management
+└── Value: Your AWS secret access key
+
+AWS_KEY_PAIR_NAME (optional - for EC2 management)
+├── Description: EC2 key pair name for instance creation
+└── Value: Name of your EC2 key pair
+```
+
+#### Variables (Repository Settings → Secrets and variables → Actions)
+
+**Required Variables:**
+```
+VALKEY_REMOTE_HOST
+├── Description: IP address or hostname of Linux runner
+├── Value: 192.168.1.100 (example)
+└── Usage: Target host for SSH connections
+```
+
+## Setup Process
+
+### Step 1: Prepare Linux Runner
+
+**Option A: Manual EC2 Setup**
+```bash
+# Launch Ubuntu 22.04 instance
+# Security group: SSH (22), Valkey (6379-6400), Cluster bus (16379-16400)
+
+# SSH to instance
+ssh -i your-key.pem ubuntu@<instance-ip>
+
+# Run setup script
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh | bash
+
+# Add public key to authorized_keys
+echo "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5... valkey-runner@github-actions" >> ~/.ssh/authorized_keys
+```
+
+**Option B: GitHub Workflow**
+```bash
+# Use setup-linux-runner.yml workflow
+gh workflow run setup-linux-runner.yml -f action=start -f instance_type=t3.medium
+```
+
+### Step 2: Configure GitHub Repository
+
+**Add SSH private key to secrets:**
+```bash
+# Copy private key content
+cat ~/.ssh/valkey_runner_key | pbcopy
+
+# Go to GitHub repo → Settings → Secrets and variables → Actions
+# New repository secret: VALKEY_RUNNER_SSH_KEY
+# Paste the private key content (including -----BEGIN/END----- lines)
+```
+
+**Add remote host to variables:**
+```bash
+# Get Linux runner IP
+curl -s http://169.254.169.254/latest/meta-data/public-ipv4  # On EC2 instance
+
+# Go to GitHub repo → Settings → Secrets and variables → Actions → Variables
+# New repository variable: VALKEY_REMOTE_HOST
+# Value: <linux-runner-ip>
+```
+
+### Step 3: Test Configuration
+
+**Manual test:**
+```bash
+# Test SSH connection
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "echo 'Connection successful'"
+
+# Test remote cluster manager
+python3 utils/remote_cluster_manager.py --host <remote-host> test
+```
+
+**Workflow test:**
+```bash
+# Trigger Java workflow on Windows
+# Check logs for "✅ Remote cluster access configured successfully"
+```
+
+## Security Best Practices
+
+### SSH Key Security
+- ✅ **Use dedicated key pair** - Don't reuse existing keys
+- ✅ **Ed25519 algorithm** - More secure than RSA
+- ✅ **No passphrase** - GitHub Actions can't handle interactive prompts
+- ✅ **Rotate regularly** - Generate new keys periodically
+
+### GitHub Secrets
+- ✅ **Repository secrets only** - Don't use organization secrets for SSH keys
+- ✅ **Minimal permissions** - Only workflows that need access
+- ✅ **Audit access** - Monitor secret usage in workflow logs
+
+### Network Security
+- ✅ **Security groups** - Restrict SSH access to GitHub IP ranges (if possible)
+- ✅ **VPC isolation** - Use private subnets with NAT gateway
+- ✅ **SSH hardening** - Disable password auth, use key-only
+
+### Instance Security
+- ✅ **Regular updates** - Keep Linux runner patched
+- ✅ **Minimal services** - Only run necessary services
+- ✅ **Monitoring** - Log SSH access and cluster operations
+
+## Credential Flow
+
+```mermaid
+sequenceDiagram
+    participant GH as GitHub Workflow
+    participant W as Windows Runner
+    participant L as Linux Runner
+    
+    GH->>W: Inject VALKEY_RUNNER_SSH_KEY secret
+    W->>W: Write SSH key to ~/.ssh/valkey_runner_key
+    W->>W: Set permissions (600)
+    W->>L: Test SSH connection
+    L-->>W: Connection successful
+    W->>L: Execute remote_cluster_manager.py
+    L->>L: Start Valkey cluster
+    L-->>W: Return cluster endpoints
+    W->>W: Run Java tests with remote endpoints
+```
+
+## Troubleshooting
+
+### SSH Connection Failures
+
+**Check SSH key format:**
+```bash
+# Key should start/end with these lines
+-----BEGIN OPENSSH PRIVATE KEY-----
+...
+-----END OPENSSH PRIVATE KEY-----
+```
+
+**Test SSH manually:**
+```bash
+# From Windows runner (in workflow)
+ssh -vvv -i ~/.ssh/valkey_runner_key ubuntu@<remote-host>
+```
+
+**Check security group:**
+```bash
+# Ensure port 22 is open
+aws ec2 describe-security-groups --group-names valkey-runner-sg
+```
+
+### Remote Cluster Failures
+
+**Check Valkey installation:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "valkey-server --version"
+```
+
+**Check cluster manager:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "cd valkey-glide/utils && python3 cluster_manager.py --help"
+```
+
+**Check firewall:**
+```bash
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-host> "sudo ufw status"
+```
+
+### GitHub Secrets Issues
+
+**Verify secret exists:**
+- Go to repo Settings → Secrets and variables → Actions
+- Confirm VALKEY_RUNNER_SSH_KEY is listed
+
+**Check secret content:**
+- Secrets are masked in logs, but you can verify length
+- Should be ~400-800 characters for Ed25519 key
+
+**Test in workflow:**
+```yaml
+- name: Debug SSH key
+  run: |
+    echo "SSH key length: ${#SSH_PRIVATE_KEY_CONTENT}"
+    echo "SSH key starts with: $(echo "$SSH_PRIVATE_KEY_CONTENT" | head -1)"
+  env:
+    SSH_PRIVATE_KEY_CONTENT: ${{ secrets.VALKEY_RUNNER_SSH_KEY }}
+```
+
+## Cost Management
+
+### Instance Lifecycle
+```bash
+# Start runner for testing
+gh workflow run setup-linux-runner.yml -f action=start
+
+# Stop runner to save costs  
+gh workflow run setup-linux-runner.yml -f action=stop
+
+# Check current status
+gh workflow run setup-linux-runner.yml -f action=status
+```
+
+### Shared Usage
+- One Linux runner can serve multiple repositories
+- Configure same VALKEY_REMOTE_HOST across repos
+- Share SSH key pair (but use separate GitHub secrets)
+
+This setup provides secure, cost-effective remote cluster access for Windows testing!
diff --git a/docs/REMOTE_CLUSTER_SETUP.md b/docs/REMOTE_CLUSTER_SETUP.md
new file mode 100644
index 0000000000..7918348ca1
--- /dev/null
+++ b/docs/REMOTE_CLUSTER_SETUP.md
@@ -0,0 +1,180 @@
+# Remote Cluster Setup for Windows Testing
+
+This document describes how to set up external Linux infrastructure for running Valkey clusters while testing on Windows.
+
+## Architecture
+
+```
+┌─────────────────┐    SSH/TCP    ┌─────────────────┐
+│  Windows Runner │ ──────────────▶│  Linux Runner   │
+│                 │               │                 │
+│ • Java Tests    │               │ • Valkey Server │
+│ • Gradle Build  │               │ • cluster_mgr   │
+│ • Remote Calls  │               │ • Self-hosted   │
+└─────────────────┘               └─────────────────┘
+```
+
+## Cost Analysis
+
+**Self-hosted runners are more cost-effective:**
+- **Containers**: Pay for compute during entire workflow (~35-40 mins)
+- **Self-hosted**: Pay only for instance uptime, shared across workflows
+- **Estimated savings**: 60-80% for frequent testing
+
+## Setup Instructions
+
+### 1. Launch Linux Runner
+
+#### Option A: Manual EC2 Setup
+```bash
+# Launch t3.medium instance with Ubuntu 22.04
+# Security group: SSH (22), Valkey (6379-6400), Cluster bus (16379-16400)
+
+# SSH to instance and run setup
+ssh -i your-key.pem ubuntu@<instance-ip>
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh | bash
+```
+
+#### Option B: GitHub Workflow
+```bash
+# Use the setup-linux-runner.yml workflow
+gh workflow run setup-linux-runner.yml -f action=start -f instance_type=t3.medium
+```
+
+### 2. Configure GitHub Secrets
+
+Add these secrets to your repository:
+
+```
+VALKEY_RUNNER_SSH_KEY: <private-key-content>
+AWS_ACCESS_KEY_ID: <aws-access-key>
+AWS_SECRET_ACCESS_KEY: <aws-secret-key>
+AWS_KEY_PAIR_NAME: <ec2-key-pair-name>
+```
+
+Add these variables:
+
+```
+VALKEY_REMOTE_HOST: <linux-runner-ip>
+```
+
+### 3. Test the Setup
+
+#### Local Test
+```bash
+# Test remote cluster manager
+python3 utils/remote_cluster_manager.py --host <linux-ip> start --cluster-mode -r 1
+
+# Test Java with remote cluster
+export VALKEY_REMOTE_HOST=<linux-ip>
+cd java && ./gradlew integTest
+```
+
+#### CI Test
+```bash
+# Windows workflow will automatically use remote cluster when VALKEY_REMOTE_HOST is set
+# No code changes needed in tests - they connect to remote endpoints transparently
+```
+
+## How It Works
+
+### Remote Cluster Manager
+
+The `remote_cluster_manager.py` script:
+
+1. **SSH Connection**: Connects to Linux runner via SSH
+2. **Repository Sync**: Ensures valkey-glide repo is up-to-date
+3. **Cluster Management**: Executes cluster_manager.py remotely
+4. **Endpoint Translation**: Converts localhost addresses to remote IPs
+5. **Result Parsing**: Returns connection strings for Java tests
+
+### Gradle Integration
+
+The Gradle build automatically detects remote mode:
+
+```gradle
+def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+if (remoteHost != null) {
+    // Use remote_cluster_manager.py
+    exec {
+        commandLine pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'start', '--cluster-mode'
+    }
+} else {
+    // Use local cluster_manager.py
+    exec {
+        commandLine pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode'
+    }
+}
+```
+
+### Java Test Transparency
+
+Java tests require no changes:
+- Gradle provides remote endpoints via system properties
+- Tests connect to `<remote-ip>:6379` instead of `localhost:6379`
+- All existing test logic works unchanged
+
+## Troubleshooting
+
+### SSH Connection Issues
+```bash
+# Test SSH connectivity
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "echo 'SSH works'"
+
+# Check security group allows SSH (port 22)
+aws ec2 describe-security-groups --group-names valkey-runner-sg
+```
+
+### Cluster Start Failures
+```bash
+# Check remote Valkey installation
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "valkey-server --version"
+
+# Check cluster manager
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "cd valkey-glide/utils && python3 cluster_manager.py --help"
+
+# Manual cluster test
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "cd valkey-glide/utils && python3 cluster_manager.py start --cluster-mode"
+```
+
+### Network Connectivity
+```bash
+# Test Valkey port access from Windows
+telnet <remote-ip> 6379
+
+# Check firewall on Linux runner
+ssh -i ~/.ssh/valkey_runner_key ubuntu@<remote-ip> "sudo ufw status"
+```
+
+## Cost Optimization
+
+### Instance Management
+```bash
+# Start runner when needed
+gh workflow run setup-linux-runner.yml -f action=start
+
+# Stop runner to save costs
+gh workflow run setup-linux-runner.yml -f action=stop
+
+# Check status
+gh workflow run setup-linux-runner.yml -f action=status
+```
+
+### Shared Usage
+- One Linux runner can serve multiple Windows workflows
+- Runner stays alive between test runs
+- Automatic cluster cleanup between tests
+
+## Security Considerations
+
+1. **SSH Keys**: Use dedicated key pair for runner access
+2. **Security Groups**: Restrict access to necessary ports only
+3. **Instance Isolation**: Use dedicated VPC if handling sensitive data
+4. **Automatic Shutdown**: Configure auto-shutdown for cost control
+
+## Performance Benefits
+
+- **No WSL overhead**: Native Linux performance for Valkey
+- **Better networking**: No WSL networking quirks
+- **Faster cluster creation**: Optimized Linux environment
+- **Consistent behavior**: Same environment as production Linux tests
diff --git a/docs/VPC_MULTI_ENGINE_SETUP.md b/docs/VPC_MULTI_ENGINE_SETUP.md
new file mode 100644
index 0000000000..90b1fac00b
--- /dev/null
+++ b/docs/VPC_MULTI_ENGINE_SETUP.md
@@ -0,0 +1,252 @@
+# VPC Multi-Engine Setup
+
+This guide explains how to set up a VPC Linux instance with multiple Valkey/Redis engine versions for testing.
+
+## Architecture
+
+```
+┌─────────────────┐    VPC/SSH    ┌─────────────────┐
+│  Windows Runner │ ──────────────▶│  VPC Linux      │
+│                 │               │                 │
+│ • Java Tests    │               │ • Multi-Engine  │
+│ • Gradle Build  │               │ • valkey-7.2    │
+│ • Engine Select │               │ • valkey-8.0    │
+└─────────────────┘               │ • valkey-8.1    │
+                                  │ • redis-6.2     │
+                                  │ • redis-7.0     │
+                                  │ • redis-7.2     │
+                                  └─────────────────┘
+```
+
+## Benefits
+
+- ✅ **Multiple Engine Versions** - Test against all supported Valkey/Redis versions
+- ✅ **VPC Performance** - Low latency within same VPC
+- ✅ **Port Isolation** - Each engine uses different port ranges
+- ✅ **Shared Infrastructure** - One instance serves multiple workflows
+- ✅ **Engine Switching** - Dynamic engine selection per test run
+
+## Setup Instructions
+
+### 1. Launch VPC Linux Instance
+
+**EC2 Configuration:**
+```bash
+# Launch Ubuntu 22.04 instance in your VPC
+# Instance type: t3.large or larger (for multiple engine builds)
+# Security group: SSH (22), Valkey ports (6379-6879), Cluster bus (16379-16879)
+# Subnet: Same VPC as your Windows runners
+```
+
+**SSH to instance and run setup:**
+```bash
+ssh -i your-key.pem ubuntu@<vpc-instance-ip>
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh | bash
+```
+
+### 2. Configure GitHub Repository
+
+**Required Secrets:**
+```
+VALKEY_VPC_SSH_KEY: <private-key-content>
+```
+
+**Required Variables:**
+```
+VALKEY_VPC_HOST: <vpc-instance-private-ip>
+```
+
+### 3. Engine Configuration
+
+**Available Engines:**
+| Engine | Version | Port Range | Binary Prefix |
+|--------|---------|------------|---------------|
+| valkey-7.2 | 7.2 | 6379-6399 | valkey |
+| valkey-8.0 | 8.0 | 6479-6499 | valkey |
+| valkey-8.1 | 8.1 | 6579-6599 | valkey |
+| redis-6.2 | 6.2 | 6679-6699 | redis |
+| redis-7.0 | 7.0 | 6779-6799 | redis |
+| redis-7.2 | 7.2 | 6879-6899 | redis |
+
+**Port Allocation:**
+- Base port = 6379 + (engine_offset)
+- Cluster bus = base_port + 10000
+- Each engine gets 20 ports for clusters
+
+## Usage
+
+### Manual Testing
+
+**Setup engines:**
+```bash
+# SSH to VPC instance
+ssh -i ~/.ssh/valkey_vpc_key ubuntu@<vpc-ip>
+
+# Setup all engines (one-time)
+python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py setup
+```
+
+**Start specific engine cluster:**
+```bash
+# Start Valkey 8.0 cluster
+python3 multi_engine_manager.py --host <vpc-ip> start --engine valkey-8.0 --cluster-mode -r 1
+
+# Start Redis 7.2 cluster  
+python3 multi_engine_manager.py --host <vpc-ip> start --engine redis-7.2 --cluster-mode -r 4
+
+# List available engines
+python3 multi_engine_manager.py --host <vpc-ip> list
+
+# Get cluster info
+python3 multi_engine_manager.py --host <vpc-ip> info --engine valkey-8.0
+```
+
+### Workflow Integration
+
+**Java Gradle:**
+```bash
+# Test against Valkey 8.0
+export VALKEY_VPC_HOST=10.0.1.100
+./gradlew integTest -Dengine-version=valkey-8.0
+
+# Test against Redis 7.2
+export VALKEY_VPC_HOST=10.0.1.100  
+./gradlew integTest -Dengine-version=redis-7.2
+```
+
+**GitHub Workflow:**
+```yaml
+# Trigger workflow with specific engine
+gh workflow run java.yml -f use-windows-self-hosted=true
+
+# Engine version is automatically detected from matrix.engine.version
+# Or can be overridden with -Dengine-version system property
+```
+
+### Configuration Priority
+
+The system checks for Valkey instances in this order:
+
+1. **VPC Instance** (`VALKEY_VPC_HOST`) - Multi-engine support
+2. **Remote Cluster** (`VALKEY_REMOTE_HOST`) - Single engine  
+3. **Local Cluster** - Default behavior
+
+## Engine Management
+
+### Installation Paths
+```
+/opt/engines/
+├── valkey-7.2/     # Valkey 7.2 source + binaries
+├── valkey-8.0/     # Valkey 8.0 source + binaries  
+├── valkey-8.1/     # Valkey 8.1 source + binaries
+├── redis-6.2/      # Redis 6.2 source + binaries
+├── redis-7.0/      # Redis 7.0 source + binaries
+└── redis-7.2/      # Redis 7.2 source + binaries
+```
+
+### Binary Locations
+```bash
+# Valkey binaries
+/opt/engines/valkey-8.0/src/valkey-server
+/opt/engines/valkey-8.0/src/valkey-cli
+
+# Redis binaries  
+/opt/engines/redis-7.2/src/redis-server
+/opt/engines/redis-7.2/src/redis-cli
+```
+
+### Engine Updates
+```bash
+# Update specific engine
+cd /opt/engines/valkey-8.0
+git pull origin 8.0
+make clean && make -j$(nproc) BUILD_TLS=yes
+
+# Update all engines
+python3 multi_engine_manager.py setup  # Rebuilds all engines
+```
+
+## Troubleshooting
+
+### SSH Connection Issues
+```bash
+# Test VPC connectivity
+ssh -i ~/.ssh/valkey_vpc_key ubuntu@<vpc-private-ip> "echo 'VPC connection works'"
+
+# Check security groups allow SSH from Windows runner subnet
+aws ec2 describe-security-groups --group-ids sg-xxxxx
+```
+
+### Engine Build Failures
+```bash
+# Check engine status
+python3 multi_engine_manager.py list
+
+# Manually rebuild failed engine
+cd /opt/engines/valkey-8.0
+make clean && make -j$(nproc) BUILD_TLS=yes
+```
+
+### Port Conflicts
+```bash
+# Check what's running on ports
+sudo netstat -tlnp | grep 637
+
+# Stop all clusters
+python3 multi_engine_manager.py stop
+
+# Stop specific engine cluster
+python3 multi_engine_manager.py stop --engine valkey-8.0
+```
+
+### Cluster Start Failures
+```bash
+# Check engine binary exists
+ls -la /opt/engines/valkey-8.0/src/valkey-server
+
+# Test engine manually
+/opt/engines/valkey-8.0/src/valkey-server --version
+
+# Check cluster manager
+cd /home/ubuntu/valkey-glide/utils
+python3 cluster_manager.py --help
+```
+
+## Performance Optimization
+
+### Instance Sizing
+- **t3.large**: Basic testing (2-3 engines)
+- **t3.xlarge**: Full matrix testing (all engines)
+- **c5.xlarge**: CPU-intensive workloads
+
+### Build Optimization
+```bash
+# Parallel builds (adjust for instance size)
+make -j$(nproc) BUILD_TLS=yes
+
+# Use ccache for faster rebuilds
+sudo apt-get install ccache
+export PATH="/usr/lib/ccache:$PATH"
+```
+
+### Network Optimization
+- Place instance in same AZ as Windows runners
+- Use placement groups for consistent performance
+- Enable enhanced networking on supported instances
+
+## Cost Management
+
+### Shared Usage
+- One VPC instance can serve multiple repositories
+- Configure same `VALKEY_VPC_HOST` across projects
+- Share SSH key pair (but use separate GitHub secrets)
+
+### Auto-Shutdown
+```bash
+# Schedule shutdown during off-hours
+echo "0 22 * * * sudo shutdown -h now" | crontab -
+
+# Or use AWS Instance Scheduler
+```
+
+This setup provides a robust, multi-engine testing environment within your VPC!
diff --git a/docs/VPC_SETUP_GUIDE.md b/docs/VPC_SETUP_GUIDE.md
new file mode 100644
index 0000000000..30273397cd
--- /dev/null
+++ b/docs/VPC_SETUP_GUIDE.md
@@ -0,0 +1,182 @@
+# VPC Setup Guide - Windows + Linux Instance Pair
+
+This guide is for your specific VPC setup with Windows instance at `3.88.53.125`.
+
+## Current Configuration
+
+```
+VPC: Your AWS VPC
+├── Windows Instance (3.88.53.125)
+│   ├── Public IP: 3.88.53.125
+│   ├── Private IP: <to be determined>
+│   └── Role: Java test runner, self-hosted GitHub runner
+└── Linux Instance
+    ├── Public IP: <optional>
+    ├── Private IP: <to be determined>
+    └── Role: Multi-engine Valkey/Redis server
+```
+
+## Setup Steps
+
+### 1. Setup Linux Instance
+
+**SSH to your Linux instance and run:**
+```bash
+# Download and run VPC setup script
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_pair.sh | bash
+```
+
+This will:
+- Install all 6 engine versions (valkey-7.2, valkey-8.0, valkey-8.1, redis-6.2, redis-7.0, redis-7.2)
+- Configure port ranges for each engine
+- Setup multi-engine manager
+- Display the private IP for GitHub configuration
+
+### 2. Test Connectivity
+
+**From your Windows instance (3.88.53.125):**
+```bash
+# Test SSH connectivity to Linux instance
+python3 utils/test_vpc_connectivity.py --linux-host <linux-private-ip> --key-path ~/.ssh/your-key.pem
+
+# Test with port checking
+python3 utils/test_vpc_connectivity.py --linux-host <linux-private-ip> --key-path ~/.ssh/your-key.pem --test-ports
+```
+
+### 3. Configure GitHub Repository
+
+**Add these to your repository settings:**
+
+**Variables (Settings → Secrets and variables → Actions → Variables):**
+```
+VALKEY_VPC_HOST=<linux-private-ip>
+```
+
+**Secrets (Settings → Secrets and variables → Actions → Secrets):**
+```
+VALKEY_VPC_SSH_KEY=<private-key-content>
+```
+
+### 4. Security Group Configuration
+
+**Ensure your security groups allow:**
+
+**Linux Instance Security Group:**
+- SSH (22) from Windows instance private IP
+- Valkey ports (6379-6879) from Windows instance private IP
+- Cluster bus ports (16379-16879) from Windows instance private IP
+
+**Windows Instance Security Group:**
+- Outbound to Linux instance on ports 22, 6379-6879, 16379-16879
+
+## Usage Examples
+
+### Manual Testing
+
+**Start specific engine cluster:**
+```bash
+# From Windows instance, test Valkey 8.0
+export VALKEY_VPC_HOST=<linux-private-ip>
+cd /path/to/valkey-glide/java
+./gradlew integTest -Dengine-version=valkey-8.0
+
+# Test Redis 7.2
+./gradlew integTest -Dengine-version=redis-7.2
+```
+
+### GitHub Workflow
+
+**Trigger workflow with VPC instance:**
+```bash
+# Use self-hosted Windows runner with VPC Linux instance
+gh workflow run java.yml -f use-windows-self-hosted=true
+```
+
+The workflow will automatically:
+1. Detect `VALKEY_VPC_HOST` is configured
+2. Use VPC instance instead of remote cluster
+3. Select engine version from test matrix
+4. Connect via private IP for optimal performance
+
+### Engine Management
+
+**List available engines:**
+```bash
+ssh ubuntu@<linux-private-ip> "python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py list"
+```
+
+**Start specific engine:**
+```bash
+ssh ubuntu@<linux-private-ip> "python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py start --engine valkey-8.0 --cluster-mode -r 1"
+```
+
+**Stop all clusters:**
+```bash
+ssh ubuntu@<linux-private-ip> "python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py stop"
+```
+
+## Port Allocation
+
+| Engine | Base Port | Port Range | Cluster Bus Range |
+|--------|-----------|------------|-------------------|
+| valkey-7.2 | 6379 | 6379-6399 | 16379-16399 |
+| valkey-8.0 | 6479 | 6479-6499 | 16479-16499 |
+| valkey-8.1 | 6579 | 6579-6599 | 16579-16599 |
+| redis-6.2 | 6679 | 6679-6699 | 16679-16699 |
+| redis-7.0 | 6779 | 6779-6799 | 16779-16799 |
+| redis-7.2 | 6879 | 6879-6899 | 16879-16899 |
+
+## Troubleshooting
+
+### Connection Issues
+
+**Test basic connectivity:**
+```bash
+# From Windows instance
+ping <linux-private-ip>
+telnet <linux-private-ip> 22
+```
+
+**Check security groups:**
+```bash
+# List security groups
+aws ec2 describe-security-groups --group-ids sg-xxxxx
+
+# Check if ports are open
+nmap -p 6379-6879 <linux-private-ip>
+```
+
+### Engine Issues
+
+**Check engine status:**
+```bash
+ssh ubuntu@<linux-private-ip> "python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py list"
+```
+
+**Rebuild specific engine:**
+```bash
+ssh ubuntu@<linux-private-ip> "cd /opt/engines/valkey-8.0 && git pull && make clean && make -j\$(nproc) BUILD_TLS=yes"
+```
+
+### Performance Optimization
+
+**For your VPC setup:**
+- Use private IPs for all communication (lower latency)
+- Place instances in same AZ if possible
+- Use enhanced networking on supported instance types
+- Consider placement groups for consistent performance
+
+## Cost Optimization
+
+**Shared Usage:**
+- One Linux instance can serve multiple Windows runners
+- Configure same `VALKEY_VPC_HOST` across multiple repositories
+- Use spot instances for cost savings (if workload allows)
+
+**Auto-Shutdown:**
+```bash
+# Schedule shutdown during off-hours (on Linux instance)
+echo "0 22 * * * sudo shutdown -h now" | crontab -
+```
+
+This VPC setup provides optimal performance and cost efficiency for your Valkey GLIDE testing!
diff --git a/java/integTest/build.gradle b/java/integTest/build.gradle
index a6efff4650..f4fda6e068 100644
--- a/java/integTest/build.gradle
+++ b/java/integTest/build.gradle
@@ -91,15 +91,64 @@ tasks.register('clearDirs', Delete) {
 tasks.register('startCluster') {
     doLast {
         if (System.getProperty("cluster-endpoints") == null) {
-            new ByteArrayOutputStream().withStream { os ->
-                exec {
-                    workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
-                    if (System.getProperty("tls") == 'true') args.add(2, '--tls')
-                    commandLine args
-                    standardOutput = os
+            // Check if we should use VPC multi-engine manager
+            def vpcHost = System.getenv("VALKEY_VPC_HOST")
+            def engineVersion = System.getProperty("engine-version") ?: "valkey-8.0"
+            
+            if (vpcHost != null && !vpcHost.isEmpty()) {
+                // Use VPC multi-engine manager
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'multi_engine_manager.py', '--host', vpcHost, 'start', '--engine', engineVersion, '--cluster-mode', '-r', '1']
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    // Parse VPC cluster endpoints
+                    def output = os.toString()
+                    def endpointsLine = output.lines().find { it.startsWith("CLUSTER_ENDPOINTS=") }
+                    if (endpointsLine) {
+                        clusterHosts = endpointsLine.substring("CLUSTER_ENDPOINTS=".length()).split(",").collect { it.trim() }
+                    } else {
+                        throw new GradleException("Failed to get cluster endpoints from VPC host: ${output}")
+                    }
+                }
+            } else {
+                // Check if we should use remote cluster manager
+                def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+                if (remoteHost != null && !remoteHost.isEmpty()) {
+                    // Use remote cluster manager
+                    new ByteArrayOutputStream().withStream { os ->
+                        exec {
+                            workingDir "${project.rootDir}/../utils"
+                            def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'start', '--cluster-mode', '-r', '1']
+                            if (System.getProperty("tls") == 'true') args.add('--tls')
+                            commandLine args
+                            standardOutput = os
+                        }
+                        // Parse remote cluster endpoints
+                        def output = os.toString()
+                        def endpointsLine = output.lines().find { it.startsWith("CLUSTER_ENDPOINTS=") }
+                        if (endpointsLine) {
+                            clusterHosts = endpointsLine.substring("CLUSTER_ENDPOINTS=".length()).split(",").collect { it.trim() }
+                        } else {
+                            throw new GradleException("Failed to get cluster endpoints from remote host: ${output}")
+                        }
+                    }
+                } else {
+                    // Use local cluster manager (original behavior)
+                    new ByteArrayOutputStream().withStream { os ->
+                        exec {
+                            workingDir "${project.rootDir}/../utils"
+                            def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '1', '--host', clusterHost]
+                            if (System.getProperty("tls") == 'true') args.add(2, '--tls')
+                            commandLine args
+                            standardOutput = os
+                        }
+                        clusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                    }
                 }
-                clusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
             }
         } else {
             clusterHosts = System.getProperty("cluster-endpoints")
@@ -110,15 +159,64 @@ tasks.register('startCluster') {
 tasks.register('startClusterForAz') {
     doLast {
         if (System.getProperty("cluster-endpoints") == null) {
-            new ByteArrayOutputStream().withStream { os ->
-                exec {
-                    workingDir "${project.rootDir}/../utils"
-                    def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
-                    if (System.getProperty("tls") == 'true') args.add(2, '--tls')
-                    commandLine args
-                    standardOutput = os
+            // Check if we should use VPC multi-engine manager
+            def vpcHost = System.getenv("VALKEY_VPC_HOST")
+            def engineVersion = System.getProperty("engine-version") ?: "valkey-8.0"
+            
+            if (vpcHost != null && !vpcHost.isEmpty()) {
+                // Use VPC multi-engine manager
+                new ByteArrayOutputStream().withStream { os ->
+                    exec {
+                        workingDir "${project.rootDir}/../utils"
+                        def args = [*pythonCmd, 'multi_engine_manager.py', '--host', vpcHost, 'start', '--engine', engineVersion, '--cluster-mode', '-r', '4']
+                        if (System.getProperty("tls") == 'true') args.add('--tls')
+                        commandLine args
+                        standardOutput = os
+                    }
+                    // Parse VPC cluster endpoints
+                    def output = os.toString()
+                    def endpointsLine = output.lines().find { it.startsWith("CLUSTER_ENDPOINTS=") }
+                    if (endpointsLine) {
+                        azClusterHosts = endpointsLine.substring("CLUSTER_ENDPOINTS=".length()).split(",").collect { it.trim() }
+                    } else {
+                        throw new GradleException("Failed to get cluster endpoints from VPC host: ${output}")
+                    }
+                }
+            } else {
+                // Check if we should use remote cluster manager
+                def remoteHost = System.getenv("VALKEY_REMOTE_HOST")
+                if (remoteHost != null && !remoteHost.isEmpty()) {
+                    // Use remote cluster manager
+                    new ByteArrayOutputStream().withStream { os ->
+                        exec {
+                            workingDir "${project.rootDir}/../utils"
+                            def args = [*pythonCmd, 'remote_cluster_manager.py', '--host', remoteHost, 'start', '--cluster-mode', '-r', '4']
+                            if (System.getProperty("tls") == 'true') args.add('--tls')
+                            commandLine args
+                            standardOutput = os
+                        }
+                        // Parse remote cluster endpoints
+                        def output = os.toString()
+                        def endpointsLine = output.lines().find { it.startsWith("CLUSTER_ENDPOINTS=") }
+                        if (endpointsLine) {
+                            azClusterHosts = endpointsLine.substring("CLUSTER_ENDPOINTS=".length()).split(",").collect { it.trim() }
+                        } else {
+                            throw new GradleException("Failed to get cluster endpoints from remote host: ${output}")
+                        }
+                    }
+                } else {
+                    // Use local cluster manager (original behavior)
+                    new ByteArrayOutputStream().withStream { os ->
+                        exec {
+                            workingDir "${project.rootDir}/../utils"
+                            def args = [*pythonCmd, 'cluster_manager.py', 'start', '--cluster-mode', '-r', '4', '--host', clusterHost]
+                            if (System.getProperty("tls") == 'true') args.add(2, '--tls')
+                            commandLine args
+                            standardOutput = os
+                        }
+                        azClusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
+                    }
                 }
-                azClusterHosts = extractAddressesFromClusterManagerOutput(os.toString())
             }
         } else {
             azClusterHosts = System.getProperty("cluster-endpoints")
diff --git a/utils/multi_engine_manager.py b/utils/multi_engine_manager.py
new file mode 100755
index 0000000000..b9cf5137ee
--- /dev/null
+++ b/utils/multi_engine_manager.py
@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+"""
+Multi-Engine Manager - Manages multiple Valkey/Redis installations on VPC Linux instance
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from typing import Dict, List, Optional, Tuple
+
+
+class MultiEngineManager:
+    def __init__(
+        self,
+        host: str,
+        user: str = "ubuntu",
+        key_path: Optional[str] = None,
+        key_content: Optional[str] = None,
+    ):
+        self.host = host
+        self.user = user
+        self.key_path = key_path
+        self.key_content = key_content
+        self.temp_key_file = None
+        self.base_path = "/opt/engines"
+        self.repo_path = "/home/ubuntu/valkey-glide"
+
+        # Engine configurations
+        self.engines = {
+            "valkey-7.2": {
+                "repo": "https://github.com/valkey-io/valkey.git",
+                "branch": "7.2",
+                "binary_prefix": "valkey",
+                "port_offset": 0,
+            },
+            "valkey-8.0": {
+                "repo": "https://github.com/valkey-io/valkey.git",
+                "branch": "8.0",
+                "binary_prefix": "valkey",
+                "port_offset": 100,
+            },
+            "valkey-8.1": {
+                "repo": "https://github.com/valkey-io/valkey.git",
+                "branch": "8.1",
+                "binary_prefix": "valkey",
+                "port_offset": 200,
+            },
+            "redis-6.2": {
+                "repo": "https://github.com/redis/redis.git",
+                "branch": "6.2",
+                "binary_prefix": "redis",
+                "port_offset": 300,
+            },
+            "redis-7.0": {
+                "repo": "https://github.com/redis/redis.git",
+                "branch": "7.0",
+                "binary_prefix": "redis",
+                "port_offset": 400,
+            },
+            "redis-7.2": {
+                "repo": "https://github.com/redis/redis.git",
+                "branch": "7.2",
+                "binary_prefix": "redis",
+                "port_offset": 500,
+            },
+        }
+
+        self._setup_ssh_key()
+
+    def _setup_ssh_key(self):
+        """Setup SSH key from various sources"""
+        if self.key_content:
+            self.temp_key_file = tempfile.NamedTemporaryFile(
+                mode="w", delete=False, suffix=".pem"
+            )
+            self.temp_key_file.write(self.key_content)
+            self.temp_key_file.close()
+            os.chmod(self.temp_key_file.name, 0o600)
+            self.key_path = self.temp_key_file.name
+
+        elif not self.key_path:
+            possible_keys = [
+                os.environ.get("SSH_PRIVATE_KEY_PATH"),
+                os.path.expanduser("~/.ssh/valkey_runner_key"),
+                os.path.expanduser("~/.ssh/id_rsa"),
+            ]
+
+            for key_file in possible_keys:
+                if key_file and os.path.exists(key_file):
+                    self.key_path = key_file
+                    break
+
+        if not self.key_path:
+            raise Exception("No SSH key found")
+
+    def __del__(self):
+        if self.temp_key_file and os.path.exists(self.temp_key_file.name):
+            os.unlink(self.temp_key_file.name)
+
+    def _execute_remote_command(
+        self, command: str, timeout: int = 300
+    ) -> Tuple[int, str, str]:
+        """Execute command on remote host via SSH"""
+        ssh_cmd = [
+            "ssh",
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
+            "-o",
+            "LogLevel=ERROR",
+        ]
+
+        if self.key_path:
+            ssh_cmd.extend(["-i", self.key_path])
+
+        ssh_cmd.extend([f"{self.user}@{self.host}", command])
+
+        try:
+            result = subprocess.run(
+                ssh_cmd, capture_output=True, text=True, timeout=timeout
+            )
+            return result.returncode, result.stdout, result.stderr
+        except subprocess.TimeoutExpired:
+            return 1, "", f"Command timed out after {timeout} seconds"
+
+    def setup_engines(self) -> bool:
+        """Install and build all engine versions"""
+        print(f"Setting up engines on {self.host}...")
+
+        # Create base directory
+        setup_cmd = f"""
+        sudo mkdir -p {self.base_path}
+        sudo chown ubuntu:ubuntu {self.base_path}
+        sudo apt-get update
+        sudo apt-get install -y build-essential git pkg-config libssl-dev python3 python3-pip
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(
+            setup_cmd, timeout=300
+        )
+        if returncode != 0:
+            print(f"Failed to setup base environment: {stderr}")
+            return False
+
+        # Install each engine
+        for engine_name, config in self.engines.items():
+            print(f"Installing {engine_name}...")
+            if not self._install_engine(engine_name, config):
+                print(f"Failed to install {engine_name}")
+                return False
+
+        # Setup valkey-glide repository
+        print("Setting up valkey-glide repository...")
+        repo_cmd = f"""
+        cd /home/ubuntu
+        if [ ! -d "valkey-glide" ]; then
+            git clone https://github.com/valkey-io/valkey-glide.git
+        fi
+        cd valkey-glide && git pull origin main
+        cd utils && pip3 install -r requirements.txt || true
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(repo_cmd)
+        if returncode != 0:
+            print(f"Warning: Failed to setup repository: {stderr}")
+
+        return True
+
+    def _install_engine(self, engine_name: str, config: Dict) -> bool:
+        """Install and build a specific engine version"""
+        engine_path = f"{self.base_path}/{engine_name}"
+
+        install_cmd = f"""
+        cd {self.base_path}
+        if [ ! -d "{engine_name}" ]; then
+            git clone {config['repo']} {engine_name}
+        fi
+        cd {engine_name}
+        git fetch origin
+        git checkout {config['branch']}
+        git pull origin {config['branch']}
+        make clean || true
+        make -j$(nproc) BUILD_TLS=yes
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(
+            install_cmd, timeout=600
+        )
+        return returncode == 0
+
+    def start_cluster(
+        self,
+        engine_version: str,
+        cluster_mode: bool = True,
+        shard_count: int = 3,
+        replica_count: int = 1,
+        tls: bool = False,
+    ) -> Optional[List[str]]:
+        """Start cluster with specific engine version"""
+
+        if engine_version not in self.engines:
+            print(f"Unknown engine version: {engine_version}")
+            return None
+
+        config = self.engines[engine_version]
+        engine_path = f"{self.base_path}/{engine_version}"
+
+        print(f"Starting {engine_version} cluster...")
+
+        # Calculate port range for this engine
+        base_port = 6379 + config["port_offset"]
+
+        # Get private IP for VPC communication
+        get_private_ip_cmd = (
+            "curl -s http://169.254.169.254/latest/meta-data/local-ipv4"
+        )
+        returncode, private_ip, stderr = self._execute_remote_command(
+            get_private_ip_cmd, timeout=10
+        )
+
+        if returncode != 0 or not private_ip.strip():
+            print("Warning: Could not get private IP, using provided host")
+            bind_host = "0.0.0.0"
+            cluster_host = self.host
+        else:
+            bind_host = "0.0.0.0"  # Bind to all interfaces
+            cluster_host = private_ip.strip()  # Use private IP for cluster endpoints
+
+        # Use modified cluster_manager.py with engine-specific settings
+        cluster_cmd = f"""
+        cd {self.repo_path}/utils
+        export PATH={engine_path}/src:$PATH
+        export ENGINE_PATH={engine_path}
+        export BASE_PORT={base_port}
+        
+        python3 cluster_manager.py start \\
+            {'--cluster-mode' if cluster_mode else ''} \\
+            -n {shard_count} \\
+            -r {replica_count} \\
+            --host {bind_host} \\
+            {'--tls' if tls else ''}
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(
+            cluster_cmd, timeout=180
+        )
+
+        if returncode != 0:
+            print(f"Failed to start {engine_version} cluster: {stderr}")
+            return None
+
+        # Parse endpoints and use private IP for VPC access
+        try:
+            lines = stdout.strip().split("\n")
+            json_line = None
+            for line in lines:
+                if line.strip().startswith("[") and line.strip().endswith("]"):
+                    json_line = line.strip()
+                    break
+
+            if json_line:
+                endpoints_data = json.loads(json_line)
+                endpoints = []
+                for endpoint in endpoints_data:
+                    if isinstance(endpoint, dict) and "port" in endpoint:
+                        # Use private IP for VPC communication
+                        endpoints.append(f"{cluster_host}:{endpoint['port']}")
+                    elif isinstance(endpoint, str) and ":" in endpoint:
+                        _, port = endpoint.split(":")
+                        endpoints.append(f"{cluster_host}:{port}")
+
+                print(f"{engine_version} cluster started. VPC endpoints: {endpoints}")
+                return endpoints
+            else:
+                print("Could not parse cluster endpoints")
+                return None
+
+        except json.JSONDecodeError as e:
+            print(f"Failed to parse output: {e}")
+            return None
+
+    def stop_cluster(self, engine_version: Optional[str] = None) -> bool:
+        """Stop cluster(s)"""
+        if engine_version:
+            print(f"Stopping {engine_version} cluster...")
+            config = self.engines.get(engine_version)
+            if not config:
+                print(f"Unknown engine version: {engine_version}")
+                return False
+
+            engine_path = f"{self.base_path}/{engine_version}"
+            stop_cmd = f"""
+            cd {self.repo_path}/utils
+            export PATH={engine_path}/src:$PATH
+            python3 cluster_manager.py stop
+            """
+        else:
+            print("Stopping all clusters...")
+            stop_cmd = f"cd {self.repo_path}/utils && python3 cluster_manager.py stop"
+
+        returncode, stdout, stderr = self._execute_remote_command(stop_cmd)
+        return returncode == 0
+
+    def list_engines(self) -> Dict:
+        """List available engines and their status"""
+        status_cmd = f"""
+        cd {self.base_path}
+        for engine in */; do
+            if [ -d "$engine" ]; then
+                engine_name=$(basename "$engine")
+                if [ -f "$engine/src/redis-server" ] || [ -f "$engine/src/valkey-server" ]; then
+                    echo "$engine_name:installed"
+                else
+                    echo "$engine_name:not_built"
+                fi
+            fi
+        done
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(status_cmd)
+
+        engines_status = {}
+        if returncode == 0:
+            for line in stdout.strip().split("\n"):
+                if ":" in line:
+                    name, status = line.split(":", 1)
+                    engines_status[name] = status
+
+        return engines_status
+
+    def get_cluster_info(self, engine_version: str) -> Optional[Dict]:
+        """Get cluster information for specific engine"""
+        if engine_version not in self.engines:
+            return None
+
+        config = self.engines[engine_version]
+        engine_path = f"{self.base_path}/{engine_version}"
+        base_port = 6379 + config["port_offset"]
+
+        info_cmd = f"""
+        cd {engine_path}/src
+        ./{config['binary_prefix']}-cli -h {self.host} -p {base_port} cluster nodes 2>/dev/null || echo "No cluster running"
+        """
+
+        returncode, stdout, stderr = self._execute_remote_command(info_cmd)
+
+        return {
+            "engine": engine_version,
+            "host": self.host,
+            "base_port": base_port,
+            "status": (
+                "running"
+                if returncode == 0 and "No cluster running" not in stdout
+                else "stopped"
+            ),
+            "cluster_info": stdout.strip() if returncode == 0 else None,
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Multi-Engine Manager for VPC Linux Instance"
+    )
+    parser.add_argument("--host", help="VPC Linux instance IP/hostname")
+    parser.add_argument("--user", default="ubuntu", help="SSH user")
+    parser.add_argument("--key-path", help="SSH private key path")
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Setup command
+    setup_parser = subparsers.add_parser("setup", help="Install all engine versions")
+
+    # Start command
+    start_parser = subparsers.add_parser(
+        "start", help="Start cluster with specific engine"
+    )
+    start_parser.add_argument(
+        "--engine", required=True, help="Engine version (e.g., valkey-8.0, redis-7.2)"
+    )
+    start_parser.add_argument(
+        "--cluster-mode", action="store_true", help="Enable cluster mode"
+    )
+    start_parser.add_argument(
+        "-n", "--shard-count", type=int, default=3, help="Number of shards"
+    )
+    start_parser.add_argument(
+        "-r", "--replica-count", type=int, default=1, help="Number of replicas"
+    )
+    start_parser.add_argument("--tls", action="store_true", help="Enable TLS")
+
+    # Stop command
+    stop_parser = subparsers.add_parser("stop", help="Stop cluster")
+    stop_parser.add_argument(
+        "--engine", help="Engine version (optional, stops all if not specified)"
+    )
+
+    # List command
+    list_parser = subparsers.add_parser("list", help="List available engines")
+
+    # Info command
+    info_parser = subparsers.add_parser("info", help="Get cluster info")
+    info_parser.add_argument("--engine", required=True, help="Engine version")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # Get credentials
+    host = args.host or os.environ.get("VALKEY_VPC_HOST")
+    if not host:
+        print(
+            "Error: Host must be specified via --host or VALKEY_VPC_HOST environment variable"
+        )
+        return 1
+
+    key_content = os.environ.get("SSH_PRIVATE_KEY_CONTENT")
+
+    try:
+        manager = MultiEngineManager(host, args.user, args.key_path, key_content)
+
+        if args.command == "setup":
+            success = manager.setup_engines()
+            return 0 if success else 1
+
+        elif args.command == "start":
+            endpoints = manager.start_cluster(
+                engine_version=args.engine,
+                cluster_mode=args.cluster_mode,
+                shard_count=args.shard_count,
+                replica_count=args.replica_count,
+                tls=args.tls,
+            )
+            if endpoints:
+                print("CLUSTER_ENDPOINTS=" + ",".join(endpoints))
+                return 0
+            else:
+                return 1
+
+        elif args.command == "stop":
+            success = manager.stop_cluster(args.engine)
+            return 0 if success else 1
+
+        elif args.command == "list":
+            engines = manager.list_engines()
+            print(json.dumps(engines, indent=2))
+            return 0
+
+        elif args.command == "info":
+            info = manager.get_cluster_info(args.engine)
+            if info:
+                print(json.dumps(info, indent=2))
+                return 0
+            else:
+                return 1
+
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/utils/remote_cluster_manager.py b/utils/remote_cluster_manager.py
new file mode 100755
index 0000000000..c3f93a4d5a
--- /dev/null
+++ b/utils/remote_cluster_manager.py
@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+Remote Cluster Manager - Executes cluster_manager.py on remote Linux instance via SSH
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from typing import List, Optional
+
+
+class RemoteClusterManager:
+    def __init__(
+        self,
+        host: str,
+        user: str = "ubuntu",
+        key_path: Optional[str] = None,
+        key_content: Optional[str] = None,
+    ):
+        self.host = host
+        self.user = user
+        self.key_path = key_path
+        self.key_content = key_content
+        self.temp_key_file = None
+        self.remote_repo_path = "/home/ubuntu/valkey-glide"
+
+        # Handle SSH key from environment or content
+        self._setup_ssh_key()
+
+    def _setup_ssh_key(self):
+        """Setup SSH key from various sources"""
+        if self.key_content:
+            # Create temporary key file from content (for GitHub secrets)
+            self.temp_key_file = tempfile.NamedTemporaryFile(
+                mode="w", delete=False, suffix=".pem"
+            )
+            self.temp_key_file.write(self.key_content)
+            self.temp_key_file.close()
+            os.chmod(self.temp_key_file.name, 0o600)
+            self.key_path = self.temp_key_file.name
+
+        elif not self.key_path:
+            # Try common key locations
+            possible_keys = [
+                os.environ.get("SSH_PRIVATE_KEY_PATH"),
+                os.path.expanduser("~/.ssh/valkey_runner_key"),
+                os.path.expanduser("~/.ssh/id_rsa"),
+                os.path.expanduser("~/.ssh/id_ed25519"),
+            ]
+
+            for key_file in possible_keys:
+                if key_file and os.path.exists(key_file):
+                    self.key_path = key_file
+                    break
+
+        if not self.key_path:
+            raise Exception(
+                "No SSH key found. Set SSH_PRIVATE_KEY_PATH or provide key content"
+            )
+
+    def __del__(self):
+        """Cleanup temporary key file"""
+        if self.temp_key_file and os.path.exists(self.temp_key_file.name):
+            os.unlink(self.temp_key_file.name)
+
+    def _build_ssh_command(self, remote_command: str) -> List[str]:
+        """Build SSH command with proper authentication"""
+        ssh_cmd = [
+            "ssh",
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
+            "-o",
+            "LogLevel=ERROR",  # Reduce noise
+        ]
+
+        if self.key_path:
+            ssh_cmd.extend(["-i", self.key_path])
+
+        ssh_cmd.extend([f"{self.user}@{self.host}", remote_command])
+        return ssh_cmd
+
+    def test_connection(self) -> bool:
+        """Test SSH connection to remote host"""
+        try:
+            returncode, stdout, stderr = self._execute_remote_command(
+                "echo 'SSH connection test'", timeout=10
+            )
+            return returncode == 0 and "SSH connection test" in stdout
+        except Exception as e:
+            print(f"SSH connection test failed: {e}")
+            return False
+
+    def _execute_remote_command(
+        self, command: str, timeout: int = 300
+    ) -> tuple[int, str, str]:
+        """Execute command on remote host via SSH"""
+        ssh_cmd = self._build_ssh_command(command)
+
+        try:
+            result = subprocess.run(
+                ssh_cmd, capture_output=True, text=True, timeout=timeout
+            )
+            return result.returncode, result.stdout, result.stderr
+        except subprocess.TimeoutExpired:
+            return 1, "", f"Command timed out after {timeout} seconds"
+
+    def setup_remote_environment(self) -> bool:
+        """Ensure remote environment is ready"""
+        print(f"Setting up remote environment on {self.host}...")
+
+        # Test connection first
+        if not self.test_connection():
+            print("❌ SSH connection failed")
+            return False
+
+        # Check if repo exists, clone if not
+        check_repo = f"test -d {self.remote_repo_path}"
+        returncode, _, _ = self._execute_remote_command(check_repo)
+
+        if returncode != 0:
+            print("Cloning valkey-glide repository...")
+            clone_cmd = f"git clone https://github.com/valkey-io/valkey-glide.git {self.remote_repo_path}"
+            returncode, stdout, stderr = self._execute_remote_command(
+                clone_cmd, timeout=120
+            )
+            if returncode != 0:
+                print(f"Failed to clone repository: {stderr}")
+                return False
+
+        # Update repository
+        print("Updating repository...")
+        update_cmd = f"cd {self.remote_repo_path} && git pull origin main"
+        returncode, stdout, stderr = self._execute_remote_command(update_cmd)
+        if returncode != 0:
+            print(f"Warning: Failed to update repository: {stderr}")
+
+        # Install dependencies
+        print("Installing Python dependencies...")
+        install_cmd = f"cd {self.remote_repo_path}/utils && pip3 install -r requirements.txt || true"
+        self._execute_remote_command(install_cmd)
+
+        return True
+
+    def start_cluster(
+        self,
+        cluster_mode: bool = True,
+        shard_count: int = 3,
+        replica_count: int = 1,
+        tls: bool = False,
+        load_module: Optional[List[str]] = None,
+    ) -> Optional[List[str]]:
+        """Start cluster on remote host and return connection endpoints"""
+
+        if not self.setup_remote_environment():
+            return None
+
+        print(
+            f"Starting cluster on {self.host} (shards={shard_count}, replicas={replica_count})..."
+        )
+
+        # Build cluster_manager.py command
+        cmd_parts = [
+            f"cd {self.remote_repo_path}/utils",
+            "&&",
+            "python3 cluster_manager.py start",
+        ]
+
+        if cluster_mode:
+            cmd_parts.append("--cluster-mode")
+        if tls:
+            cmd_parts.append("--tls")
+
+        cmd_parts.extend(["-n", str(shard_count), "-r", str(replica_count)])
+        cmd_parts.extend(
+            ["--host", "0.0.0.0"]
+        )  # Bind to all interfaces for external access
+
+        if load_module:
+            for module in load_module:
+                cmd_parts.extend(["--load-module", module])
+
+        remote_command = " ".join(cmd_parts)
+
+        # Execute cluster start
+        returncode, stdout, stderr = self._execute_remote_command(
+            remote_command, timeout=180
+        )
+
+        if returncode != 0:
+            print(f"Failed to start cluster: {stderr}")
+            return None
+
+        # Parse cluster endpoints from output
+        try:
+            # Look for JSON output in stdout
+            lines = stdout.strip().split("\n")
+            json_line = None
+            for line in lines:
+                if line.strip().startswith("[") and line.strip().endswith("]"):
+                    json_line = line.strip()
+                    break
+
+            if json_line:
+                endpoints_data = json.loads(json_line)
+                # Convert localhost to remote host IP
+                endpoints = []
+                for endpoint in endpoints_data:
+                    if (
+                        isinstance(endpoint, dict)
+                        and "host" in endpoint
+                        and "port" in endpoint
+                    ):
+                        endpoints.append(f"{self.host}:{endpoint['port']}")
+                    elif isinstance(endpoint, str):
+                        # Handle string format like "127.0.0.1:6379"
+                        _, port = endpoint.split(":")
+                        endpoints.append(f"{self.host}:{port}")
+
+                print(f"Cluster started successfully. Endpoints: {endpoints}")
+                return endpoints
+            else:
+                print("Could not parse cluster endpoints from output")
+                print(f"stdout: {stdout}")
+                return None
+
+        except json.JSONDecodeError as e:
+            print(f"Failed to parse cluster output: {e}")
+            print(f"stdout: {stdout}")
+            return None
+
+    def stop_cluster(self) -> bool:
+        """Stop cluster on remote host"""
+        print(f"Stopping cluster on {self.host}...")
+
+        stop_cmd = (
+            f"cd {self.remote_repo_path}/utils && python3 cluster_manager.py stop"
+        )
+        returncode, stdout, stderr = self._execute_remote_command(stop_cmd)
+
+        if returncode != 0:
+            print(f"Failed to stop cluster: {stderr}")
+            return False
+
+        print("Cluster stopped successfully")
+        return True
+
+    def get_cluster_status(self) -> Optional[dict]:
+        """Get cluster status from remote host"""
+        status_cmd = f"cd {self.remote_repo_path}/utils && python3 cluster_manager.py status || echo 'No cluster running'"
+        returncode, stdout, stderr = self._execute_remote_command(status_cmd)
+
+        # Return basic status info
+        return {
+            "host": self.host,
+            "status": "running" if returncode == 0 else "stopped",
+            "output": stdout.strip(),
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Remote Cluster Manager")
+    parser.add_argument("--host", help="Remote Linux host IP/hostname")
+    parser.add_argument("--user", default="ubuntu", help="SSH user (default: ubuntu)")
+    parser.add_argument("--key-path", help="SSH private key path")
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Start command
+    start_parser = subparsers.add_parser("start", help="Start remote cluster")
+    start_parser.add_argument(
+        "--cluster-mode", action="store_true", help="Enable cluster mode"
+    )
+    start_parser.add_argument(
+        "-n", "--shard-count", type=int, default=3, help="Number of shards"
+    )
+    start_parser.add_argument(
+        "-r", "--replica-count", type=int, default=1, help="Number of replicas"
+    )
+    start_parser.add_argument("--tls", action="store_true", help="Enable TLS")
+    start_parser.add_argument("--load-module", action="append", help="Load module")
+
+    # Stop command
+    stop_parser = subparsers.add_parser("stop", help="Stop remote cluster")
+
+    # Status command
+    status_parser = subparsers.add_parser("status", help="Get cluster status")
+
+    # Test command
+    test_parser = subparsers.add_parser("test", help="Test SSH connection")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # Get credentials from environment or arguments
+    host = args.host or os.environ.get("VALKEY_REMOTE_HOST")
+    if not host:
+        print(
+            "Error: Remote host must be specified via --host or VALKEY_REMOTE_HOST environment variable"
+        )
+        return 1
+
+    # Get SSH key from multiple sources
+    key_path = args.key_path
+    key_content = os.environ.get("SSH_PRIVATE_KEY_CONTENT")  # For GitHub secrets
+
+    try:
+        manager = RemoteClusterManager(host, args.user, key_path, key_content)
+
+        if args.command == "test":
+            if manager.test_connection():
+                print("✅ SSH connection successful")
+                return 0
+            else:
+                print("❌ SSH connection failed")
+                return 1
+
+        elif args.command == "start":
+            endpoints = manager.start_cluster(
+                cluster_mode=args.cluster_mode,
+                shard_count=args.shard_count,
+                replica_count=args.replica_count,
+                tls=args.tls,
+                load_module=args.load_module,
+            )
+            if endpoints:
+                # Output endpoints in format expected by Gradle
+                print("CLUSTER_ENDPOINTS=" + ",".join(endpoints))
+                return 0
+            else:
+                return 1
+
+        elif args.command == "stop":
+            success = manager.stop_cluster()
+            return 0 if success else 1
+
+        elif args.command == "status":
+            status = manager.get_cluster_status()
+            if status:
+                print(json.dumps(status, indent=2))
+                return 0
+            else:
+                return 1
+
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/utils/setup_linux_runner.sh b/utils/setup_linux_runner.sh
new file mode 100755
index 0000000000..bb7b881456
--- /dev/null
+++ b/utils/setup_linux_runner.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+# Setup script for Linux runner with Valkey support
+
+set -e
+
+echo "Setting up Linux runner for Valkey GLIDE tests..."
+
+# Update system
+sudo apt-get update
+sudo apt-get install -y python3 python3-pip git build-essential pkg-config libssl-dev curl
+
+# Install Valkey
+echo "Installing Valkey..."
+cd /tmp
+if [ ! -d "valkey" ]; then
+    git clone https://github.com/valkey-io/valkey.git
+fi
+cd valkey
+git checkout 8.0.1  # Use stable version
+make -j$(nproc) BUILD_TLS=yes
+sudo make install
+
+# Verify Valkey installation
+echo "Verifying Valkey installation..."
+valkey-server --version
+valkey-cli --version
+
+# Install Python dependencies
+echo "Installing Python dependencies..."
+pip3 install psutil
+
+# Clone valkey-glide repository
+echo "Setting up valkey-glide repository..."
+cd /home/ubuntu
+if [ ! -d "valkey-glide" ]; then
+    git clone https://github.com/valkey-io/valkey-glide.git
+fi
+cd valkey-glide
+git pull origin main
+
+# Install Python requirements for cluster manager
+cd utils
+pip3 install -r requirements.txt || echo "No requirements.txt found, continuing..."
+
+# Test cluster manager
+echo "Testing cluster manager..."
+python3 cluster_manager.py --help
+
+# Configure firewall for Valkey ports
+echo "Configuring firewall..."
+sudo ufw allow 22/tcp      # SSH
+sudo ufw allow 6379:6400/tcp  # Valkey ports
+sudo ufw allow 16379:16400/tcp # Valkey cluster bus ports
+sudo ufw --force enable
+
+# Create systemd service for keeping runner alive
+echo "Creating runner service..."
+sudo tee /etc/systemd/system/valkey-runner.service > /dev/null << EOF
+[Unit]
+Description=Valkey Test Runner
+After=network.target
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu/valkey-glide
+ExecStart=/bin/bash -c 'while true; do sleep 60; done'
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+sudo systemctl daemon-reload
+sudo systemctl enable valkey-runner
+sudo systemctl start valkey-runner
+
+echo "Linux runner setup complete!"
+echo ""
+echo "Runner is ready to accept remote cluster management requests."
+echo "Use the following environment variables in Windows tests:"
+echo "  VALKEY_REMOTE_HOST=$(curl -s http://169.254.169.254/latest/meta-data/public-ipv4)"
+echo ""
+echo "Test the setup with:"
+echo "  python3 /home/ubuntu/valkey-glide/utils/remote_cluster_manager.py --host localhost start --cluster-mode"
diff --git a/utils/setup_vpc_instance.sh b/utils/setup_vpc_instance.sh
new file mode 100755
index 0000000000..f7527ea00b
--- /dev/null
+++ b/utils/setup_vpc_instance.sh
@@ -0,0 +1,150 @@
+#!/bin/bash
+# Setup script for VPC Linux instance with multi-engine Valkey/Redis support
+
+set -e
+
+echo "Setting up VPC Linux instance for multi-engine Valkey/Redis testing..."
+
+# Update system
+sudo apt-get update
+sudo apt-get install -y build-essential git pkg-config libssl-dev python3 python3-pip curl jq
+
+# Create engines directory
+sudo mkdir -p /opt/engines
+sudo chown ubuntu:ubuntu /opt/engines
+
+# Install engines
+cd /opt/engines
+
+echo "Installing Valkey versions..."
+
+# Valkey 7.2
+if [ ! -d "valkey-7.2" ]; then
+    git clone https://github.com/valkey-io/valkey.git valkey-7.2
+    cd valkey-7.2
+    git checkout 7.2
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+# Valkey 8.0
+if [ ! -d "valkey-8.0" ]; then
+    git clone https://github.com/valkey-io/valkey.git valkey-8.0
+    cd valkey-8.0
+    git checkout 8.0
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+# Valkey 8.1
+if [ ! -d "valkey-8.1" ]; then
+    git clone https://github.com/valkey-io/valkey.git valkey-8.1
+    cd valkey-8.1
+    git checkout 8.1
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+echo "Installing Redis versions..."
+
+# Redis 6.2
+if [ ! -d "redis-6.2" ]; then
+    git clone https://github.com/redis/redis.git redis-6.2
+    cd redis-6.2
+    git checkout 6.2
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+# Redis 7.0
+if [ ! -d "redis-7.0" ]; then
+    git clone https://github.com/redis/redis.git redis-7.0
+    cd redis-7.0
+    git checkout 7.0
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+# Redis 7.2
+if [ ! -d "redis-7.2" ]; then
+    git clone https://github.com/redis/redis.git redis-7.2
+    cd redis-7.2
+    git checkout 7.2
+    make -j$(nproc) BUILD_TLS=yes
+    cd ..
+fi
+
+# Setup valkey-glide repository
+echo "Setting up valkey-glide repository..."
+cd /home/ubuntu
+if [ ! -d "valkey-glide" ]; then
+    git clone https://github.com/valkey-io/valkey-glide.git
+fi
+cd valkey-glide
+git pull origin main
+
+# Install Python dependencies
+cd utils
+pip3 install psutil || true
+
+# Make scripts executable
+chmod +x multi_engine_manager.py
+chmod +x cluster_manager.py
+
+# Configure firewall for all engine ports
+echo "Configuring firewall..."
+sudo ufw allow 22/tcp      # SSH
+sudo ufw allow 6379:6879/tcp  # All engine ports (6379-6879)
+sudo ufw allow 16379:16879/tcp # All cluster bus ports
+sudo ufw --force enable
+
+# Create systemd service for multi-engine manager
+echo "Creating multi-engine service..."
+sudo tee /etc/systemd/system/valkey-multi-engine.service > /dev/null << EOF
+[Unit]
+Description=Valkey Multi-Engine Manager
+After=network.target
+
+[Service]
+Type=simple
+User=ubuntu
+WorkingDirectory=/home/ubuntu/valkey-glide/utils
+ExecStart=/bin/bash -c 'while true; do sleep 60; done'
+Restart=always
+RestartSec=10
+Environment=PATH=/opt/engines/valkey-8.0/src:/opt/engines/valkey-8.1/src:/opt/engines/valkey-7.2/src:/opt/engines/redis-7.2/src:/opt/engines/redis-7.0/src:/opt/engines/redis-6.2/src:/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+sudo systemctl daemon-reload
+sudo systemctl enable valkey-multi-engine
+sudo systemctl start valkey-multi-engine
+
+# Test installations
+echo "Testing engine installations..."
+for engine in valkey-7.2 valkey-8.0 valkey-8.1 redis-6.2 redis-7.0 redis-7.2; do
+    if [ -f "/opt/engines/$engine/src/redis-server" ] || [ -f "/opt/engines/$engine/src/valkey-server" ]; then
+        echo "✅ $engine: installed"
+    else
+        echo "❌ $engine: failed to build"
+    fi
+done
+
+# Test multi-engine manager
+echo "Testing multi-engine manager..."
+python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py list
+
+echo ""
+echo "VPC Linux instance setup complete!"
+echo ""
+echo "Available engines:"
+echo "  - valkey-7.2, valkey-8.0, valkey-8.1"
+echo "  - redis-6.2, redis-7.0, redis-7.2"
+echo ""
+echo "Instance IP: $(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)"
+echo ""
+echo "Usage in workflows:"
+echo "  export VALKEY_VPC_HOST=$(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)"
+echo "  ./gradlew integTest -Dengine-version=valkey-8.0"
diff --git a/utils/setup_vpc_pair.sh b/utils/setup_vpc_pair.sh
new file mode 100755
index 0000000000..fa2ac8b4cf
--- /dev/null
+++ b/utils/setup_vpc_pair.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+# Setup script for VPC Windows + Linux instance pair
+
+set -e
+
+WINDOWS_PUBLIC_IP="3.88.53.125"
+LINUX_PRIVATE_IP=""
+WINDOWS_PRIVATE_IP=""
+
+echo "Setting up VPC instance pair for Valkey GLIDE testing..."
+
+# Detect if we're on the Linux instance
+if [ -f /etc/os-release ] && grep -q "Ubuntu" /etc/os-release; then
+    echo "Detected Linux instance - setting up multi-engine server..."
+    
+    # Get our private IP
+    LINUX_PRIVATE_IP=$(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)
+    echo "Linux private IP: $LINUX_PRIVATE_IP"
+    
+    # Run the standard VPC setup
+    curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh | bash
+    
+    # Additional VPC-specific configuration
+    echo "Configuring VPC-specific settings..."
+    
+    # Allow Windows instance access (add to security group if needed)
+    echo "Linux instance setup complete!"
+    echo ""
+    echo "Configuration for GitHub:"
+    echo "  VALKEY_VPC_HOST=$LINUX_PRIVATE_IP"
+    echo ""
+    echo "Test from Windows instance:"
+    echo "  ssh ubuntu@$LINUX_PRIVATE_IP 'python3 /home/ubuntu/valkey-glide/utils/multi_engine_manager.py list'"
+    
+else
+    echo "This script should be run on the Linux instance in your VPC."
+    echo "For Windows instance setup, use the GitHub workflow configuration."
+    echo ""
+    echo "Manual setup steps:"
+    echo "1. SSH to Linux instance and run this script"
+    echo "2. Configure GitHub variables:"
+    echo "   - VALKEY_VPC_HOST=<linux-private-ip>"
+    echo "3. Configure GitHub secrets:"
+    echo "   - VALKEY_VPC_SSH_KEY=<private-key-content>"
+    echo "4. Test Windows → Linux connectivity"
+    exit 1
+fi
diff --git a/utils/test_vpc_connectivity.py b/utils/test_vpc_connectivity.py
new file mode 100755
index 0000000000..9dc61cb313
--- /dev/null
+++ b/utils/test_vpc_connectivity.py
@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+VPC Connectivity Test - Test Windows → Linux VPC connectivity
+"""
+
+import argparse
+import socket
+import subprocess
+import sys
+import time
+from typing import List, Tuple
+
+
+def test_ssh_connection(host: str, user: str = "ubuntu", key_path: str = None) -> bool:
+    """Test SSH connectivity"""
+    print(f"Testing SSH connection to {host}...")
+
+    ssh_cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "StrictHostKeyChecking=no"]
+    if key_path:
+        ssh_cmd.extend(["-i", key_path])
+    ssh_cmd.extend([f"{user}@{host}", "echo 'SSH connection successful'"])
+
+    try:
+        result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=15)
+        if result.returncode == 0 and "SSH connection successful" in result.stdout:
+            print("✅ SSH connection successful")
+            return True
+        else:
+            print(f"❌ SSH connection failed: {result.stderr}")
+            return False
+    except subprocess.TimeoutExpired:
+        print("❌ SSH connection timed out")
+        return False
+    except Exception as e:
+        print(f"❌ SSH connection error: {e}")
+        return False
+
+
+def test_port_connectivity(host: str, ports: List[int]) -> List[Tuple[int, bool]]:
+    """Test TCP port connectivity"""
+    print(f"Testing port connectivity to {host}...")
+
+    results = []
+    for port in ports:
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(5)
+            result = sock.connect_ex((host, port))
+            sock.close()
+
+            success = result == 0
+            status = "✅ Open" if success else "❌ Closed"
+            print(f"  Port {port}: {status}")
+            results.append((port, success))
+
+        except Exception as e:
+            print(f"  Port {port}: ❌ Error - {e}")
+            results.append((port, False))
+
+    return results
+
+
+def test_multi_engine_manager(host: str, key_path: str = None) -> bool:
+    """Test multi-engine manager functionality"""
+    print(f"Testing multi-engine manager on {host}...")
+
+    ssh_cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "StrictHostKeyChecking=no"]
+    if key_path:
+        ssh_cmd.extend(["-i", key_path])
+    ssh_cmd.extend(
+        [
+            f"ubuntu@{host}",
+            "cd /home/ubuntu/valkey-glide/utils && python3 multi_engine_manager.py list",
+        ]
+    )
+
+    try:
+        result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=30)
+        if result.returncode == 0:
+            print("✅ Multi-engine manager working")
+            print("Available engines:")
+            for line in result.stdout.strip().split("\n"):
+                if line.strip():
+                    print(f"  {line}")
+            return True
+        else:
+            print(f"❌ Multi-engine manager failed: {result.stderr}")
+            return False
+    except Exception as e:
+        print(f"❌ Multi-engine manager error: {e}")
+        return False
+
+
+def get_instance_info(host: str, key_path: str = None) -> dict:
+    """Get instance information"""
+    print(f"Getting instance information from {host}...")
+
+    info_cmd = """
+    echo "Private IP: $(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)"
+    echo "Public IP: $(curl -s http://169.254.169.254/latest/meta-data/public-ipv4)"
+    echo "Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)"
+    echo "AZ: $(curl -s http://169.254.169.254/latest/meta-data/placement/availability-zone)"
+    """
+
+    ssh_cmd = ["ssh", "-o", "ConnectTimeout=10", "-o", "StrictHostKeyChecking=no"]
+    if key_path:
+        ssh_cmd.extend(["-i", key_path])
+    ssh_cmd.extend([f"ubuntu@{host}", info_cmd])
+
+    try:
+        result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=15)
+        if result.returncode == 0:
+            info = {}
+            for line in result.stdout.strip().split("\n"):
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    info[key.strip()] = value.strip()
+            return info
+        else:
+            print(f"❌ Failed to get instance info: {result.stderr}")
+            return {}
+    except Exception as e:
+        print(f"❌ Instance info error: {e}")
+        return {}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Test VPC connectivity for Valkey GLIDE"
+    )
+    parser.add_argument(
+        "--linux-host", required=True, help="Linux instance IP (private IP recommended)"
+    )
+    parser.add_argument("--key-path", help="SSH private key path")
+    parser.add_argument(
+        "--test-ports", action="store_true", help="Test Valkey port ranges"
+    )
+
+    args = parser.parse_args()
+
+    print("🔍 VPC Connectivity Test for Valkey GLIDE")
+    print("=" * 50)
+
+    # Test SSH connectivity
+    ssh_ok = test_ssh_connection(args.linux_host, key_path=args.key_path)
+    if not ssh_ok:
+        print("\n❌ SSH connectivity failed. Check:")
+        print("1. Security group allows SSH (port 22) from Windows instance")
+        print("2. SSH key is correct")
+        print("3. Linux instance is running")
+        return 1
+
+    # Get instance information
+    print("\n📋 Instance Information:")
+    info = get_instance_info(args.linux_host, key_path=args.key_path)
+    for key, value in info.items():
+        print(f"  {key}: {value}")
+
+    # Test multi-engine manager
+    print("\n🔧 Multi-Engine Manager Test:")
+    manager_ok = test_multi_engine_manager(args.linux_host, key_path=args.key_path)
+
+    # Test port connectivity if requested
+    if args.test_ports:
+        print("\n🔌 Port Connectivity Test:")
+        test_ports = [
+            6379,  # valkey-7.2
+            6479,  # valkey-8.0
+            6579,  # valkey-8.1
+            6679,  # redis-6.2
+            6779,  # redis-7.0
+            6879,  # redis-7.2
+        ]
+        port_results = test_port_connectivity(args.linux_host, test_ports)
+
+        open_ports = [port for port, success in port_results if success]
+        if open_ports:
+            print(f"✅ {len(open_ports)} ports accessible")
+        else:
+            print("⚠️ No Valkey ports currently open (clusters not running)")
+
+    # Summary
+    print("\n📊 Test Summary:")
+    print(f"  SSH Connection: {'✅ Pass' if ssh_ok else '❌ Fail'}")
+    print(f"  Multi-Engine Manager: {'✅ Pass' if manager_ok else '❌ Fail'}")
+
+    if ssh_ok and manager_ok:
+        print("\n🎉 VPC connectivity test passed!")
+        print("\nNext steps:")
+        print("1. Configure GitHub variables:")
+        print(f"   VALKEY_VPC_HOST={args.linux_host}")
+        print("2. Configure GitHub secrets:")
+        print("   VALKEY_VPC_SSH_KEY=<private-key-content>")
+        print("3. Run Java tests with VPC instance")
+        return 0
+    else:
+        print("\n❌ VPC connectivity test failed!")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

From 535778dff966cb536c3cd12011b89d09da27f788 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:17:47 -0700
Subject: [PATCH 091/106] Use remote administration in ValkeyCluster

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../java/glide/cluster/ValkeyCluster.java     | 257 +++++++++++++++---
 utils/cluster_manager.py                      |  49 +++-
 2 files changed, 270 insertions(+), 36 deletions(-)

diff --git a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
index 2ee5c6fa1e..24566baa1a 100644
--- a/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
+++ b/java/integTest/src/test/java/glide/cluster/ValkeyCluster.java
@@ -21,19 +21,73 @@ public class ValkeyCluster implements AutoCloseable {
                     .resolve("utils")
                     .resolve("cluster_manager.py");
 
+    private static final Path VPC_MANAGER_SCRIPT =
+            Paths.get(System.getProperty("user.dir"))
+                    .getParent()
+                    .getParent()
+                    .resolve("utils")
+                    .resolve("multi_engine_manager.py");
+
+    private static final Path REMOTE_MANAGER_SCRIPT =
+            Paths.get(System.getProperty("user.dir"))
+                    .getParent()
+                    .getParent()
+                    .resolve("utils")
+                    .resolve("remote_cluster_manager.py");
+
     /** Get platform-specific Python command with WSL support */
     private static List<String> getPythonCommand() {
         String osName = System.getProperty("os.name").toLowerCase();
         if (osName.contains("windows")) {
-            return Arrays.asList("wsl", "--", "python3");
+            // Check if we should use VPC or remote cluster managers
+            String vpcHost = System.getenv("VALKEY_VPC_HOST");
+            String remoteHost = System.getenv("VALKEY_REMOTE_HOST");
+
+            if (vpcHost != null || remoteHost != null) {
+                // Use native Windows Python for remote/VPC managers
+                return Arrays.asList("python3");
+            } else {
+                // Use WSL for local cluster manager
+                return Arrays.asList("wsl", "--", "python3");
+            }
         } else {
             return Arrays.asList("python3");
         }
     }
 
+    /** Get the appropriate cluster manager script and arguments */
+    private static ClusterManagerInfo getClusterManagerInfo() {
+        String vpcHost = System.getenv("VALKEY_VPC_HOST");
+        String remoteHost = System.getenv("VALKEY_REMOTE_HOST");
+
+        if (vpcHost != null && !vpcHost.isEmpty()) {
+            // Use VPC multi-engine manager
+            return new ClusterManagerInfo(VPC_MANAGER_SCRIPT, "vpc", vpcHost);
+        } else if (remoteHost != null && !remoteHost.isEmpty()) {
+            // Use remote cluster manager
+            return new ClusterManagerInfo(REMOTE_MANAGER_SCRIPT, "remote", remoteHost);
+        } else {
+            // Use local cluster manager
+            return new ClusterManagerInfo(SCRIPT_FILE, "local", null);
+        }
+    }
+
+    private static class ClusterManagerInfo {
+        final Path scriptPath;
+        final String type;
+        final String host;
+
+        ClusterManagerInfo(Path scriptPath, String type, String host) {
+            this.scriptPath = scriptPath;
+            this.type = type;
+            this.host = host;
+        }
+    }
+
     private boolean tls = false;
     private String clusterFolder;
     private List<NodeAddress> nodesAddr;
+    private ClusterManagerInfo managerInfo;
 
     /**
      * Creates a new ValkeyCluster instance
@@ -54,15 +108,54 @@ public ValkeyCluster(
             List<List<String>> addresses)
             throws IOException, InterruptedException {
 
+        this.managerInfo = getClusterManagerInfo();
+
         if (addresses != null && !addresses.isEmpty()) {
             initFromExistingCluster(addresses);
         } else {
             this.tls = tls;
             List<String> command = new ArrayList<>();
             command.addAll(getPythonCommand());
-            command.add(SCRIPT_FILE.toString());
+            command.add(managerInfo.scriptPath.toString());
+
+            // Add manager-specific arguments
+            if ("vpc".equals(managerInfo.type)) {
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("start");
+
+                // Add engine version if specified
+                String engineVersion = System.getProperty("engine-version", "valkey-8.0");
+                command.add("--engine");
+                command.add(engineVersion);
+
+                if (clusterMode) {
+                    command.add("--cluster-mode");
+                }
+            } else if ("remote".equals(managerInfo.type)) {
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("start");
+
+                if (clusterMode) {
+                    command.add("--cluster-mode");
+                }
+            } else {
+                // Local cluster manager
+                command.add("start"); // Action must come first
 
-            command.add("start"); // Action must come first
+                if (clusterMode) {
+                    command.add("--cluster-mode");
+                }
+
+                // Add host parameter - use environment variable or default to localhost
+                String host = System.getenv("VALKEY_INTEG_TEST_IP");
+                if (host == null || host.isEmpty()) {
+                    host = "127.0.0.1";
+                }
+                command.add("--host");
+                command.add(host);
+            }
 
             if (tls) {
                 command.add("--tls");
@@ -73,18 +166,6 @@ public ValkeyCluster(
             command.add("-r");
             command.add(String.valueOf(replicaCount));
 
-            // Add host parameter - use environment variable or default to localhost
-            String host = System.getenv("VALKEY_INTEG_TEST_IP");
-            if (host == null || host.isEmpty()) {
-                host = "127.0.0.1";
-            }
-            command.add("--host");
-            command.add(host);
-
-            if (clusterMode) {
-                command.add("--cluster-mode");
-            }
-
             if (loadModule != null && !loadModule.isEmpty()) {
                 for (String module : loadModule) {
                     command.add("--load-module");
@@ -105,7 +186,7 @@ public ValkeyCluster(
                 }
             }
 
-            if (!process.waitFor(80, TimeUnit.SECONDS)) {
+            if (!process.waitFor(120, TimeUnit.SECONDS)) { // Increased timeout for remote operations
                 process.destroy();
                 throw new RuntimeException("Timeout waiting for cluster creation");
             }
@@ -114,7 +195,97 @@ public ValkeyCluster(
                 throw new RuntimeException("Failed to create cluster: " + output);
             }
 
-            parseClusterScriptStartOutput(output.toString());
+            if ("vpc".equals(managerInfo.type) || "remote".equals(managerInfo.type)) {
+                parseRemoteClusterOutput(output.toString());
+            } else {
+                parseClusterScriptStartOutput(output.toString());
+            }
+        }
+    }
+
+    /** Constructor with default values */
+    public ValkeyCluster(boolean tls) throws IOException, InterruptedException {
+        this(tls, false, 3, 1, null, null);
+    }
+
+    private void parseRemoteClusterOutput(String output) {
+        // Parse CLUSTER_ENDPOINTS=host1:port1,host2:port2,... format
+        for (String line : output.split("\n")) {
+            if (line.contains("CLUSTER_ENDPOINTS=")) {
+                this.nodesAddr = new ArrayList<>();
+                String[] parts = line.split("CLUSTER_ENDPOINTS=");
+                if (parts.length != 2) {
+                    throw new IllegalArgumentException("Invalid CLUSTER_ENDPOINTS format");
+                }
+
+                String[] endpoints = parts[1].split(",");
+                if (endpoints.length == 0) {
+                    throw new IllegalArgumentException("No cluster endpoints found");
+                }
+
+                for (String endpoint : endpoints) {
+                    String[] hostPort = endpoint.trim().split(":");
+                    if (hostPort.length != 2) {
+                        throw new IllegalArgumentException("Invalid endpoint format: " + endpoint);
+                    }
+
+                    try {
+                        int port = Integer.parseInt(hostPort[1]);
+                        this.nodesAddr.add(NodeAddress.builder().host(hostPort[0]).port(port).build());
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException("Invalid port number in endpoint: " + endpoint);
+                    }
+                }
+
+                // Set a dummy cluster folder for remote clusters
+                this.clusterFolder = "remote-cluster";
+                return;
+            }
+        }
+
+        throw new IllegalArgumentException("No CLUSTER_ENDPOINTS found in output: " + output);
+    }
+
+    private void parseClusterScriptStartOutput(String output) {
+        if (!output.contains("CLUSTER_FOLDER") || !output.contains("CLUSTER_NODES")) {
+            throw new IllegalArgumentException("Invalid cluster script output");
+        }
+
+        for (String line : output.split("\n")) {
+            if (line.contains("CLUSTER_FOLDER=")) {
+                String[] parts = line.split("CLUSTER_FOLDER=");
+                if (parts.length != 2) {
+                    throw new IllegalArgumentException("Invalid CLUSTER_FOLDER format");
+                }
+                this.clusterFolder = parts[1];
+            }
+
+            if (line.contains("CLUSTER_NODES=")) {
+                this.nodesAddr = new ArrayList<>();
+                String[] parts = line.split("CLUSTER_NODES=");
+                if (parts.length != 2) {
+                    throw new IllegalArgumentException("Invalid CLUSTER_NODES format");
+                }
+
+                String[] addresses = parts[1].split(",");
+                if (addresses.length == 0) {
+                    throw new IllegalArgumentException("No cluster nodes found");
+                }
+
+                for (String address : addresses) {
+                    String[] hostPort = address.split(":");
+                    if (hostPort.length != 2) {
+                        throw new IllegalArgumentException("Invalid address format");
+                    }
+
+                    try {
+                        int port = Integer.parseInt(hostPort[1]);
+                        this.nodesAddr.add(NodeAddress.builder().host(hostPort[0]).port(port).build());
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException("Invalid port number");
+                    }
+                }
+            }
         }
     }
 
@@ -193,24 +364,44 @@ public void close() throws IOException {
         if (clusterFolder != null && !clusterFolder.isEmpty()) {
             List<String> command = new ArrayList<>();
             command.addAll(getPythonCommand());
-            command.add(SCRIPT_FILE.toString());
 
-            if (tls) {
-                command.add("--tls");
-            }
+            // Use appropriate script based on manager type
+            if ("vpc".equals(managerInfo.type)) {
+                command.add(managerInfo.scriptPath.toString());
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("stop");
+
+                // Add engine version if specified
+                String engineVersion = System.getProperty("engine-version", "valkey-8.0");
+                command.add("--engine");
+                command.add(engineVersion);
+            } else if ("remote".equals(managerInfo.type)) {
+                command.add(managerInfo.scriptPath.toString());
+                command.add("--host");
+                command.add(managerInfo.host);
+                command.add("stop");
+            } else {
+                // Local cluster manager
+                command.add(managerInfo.scriptPath.toString());
+
+                if (tls) {
+                    command.add("--tls");
+                }
 
-            command.add("stop");
+                command.add("stop");
 
-            // Add host parameter - use environment variable or default to localhost
-            String host = System.getenv("VALKEY_INTEG_TEST_IP");
-            if (host == null || host.isEmpty()) {
-                host = "127.0.0.1";
-            }
-            command.add("--host");
-            command.add(host);
+                // Add host parameter - use environment variable or default to localhost
+                String host = System.getenv("VALKEY_INTEG_TEST_IP");
+                if (host == null || host.isEmpty()) {
+                    host = "127.0.0.1";
+                }
+                command.add("--host");
+                command.add(host);
 
-            command.add("--cluster-folder");
-            command.add(clusterFolder);
+                command.add("--cluster-folder");
+                command.add(clusterFolder);
+            }
 
             ProcessBuilder pb = new ProcessBuilder(command);
             pb.redirectErrorStream(true);
@@ -226,7 +417,9 @@ public void close() throws IOException {
             }
 
             try {
-                if (!process.waitFor(20, TimeUnit.SECONDS)) {
+                int timeoutSeconds =
+                        ("vpc".equals(managerInfo.type) || "remote".equals(managerInfo.type)) ? 30 : 20;
+                if (!process.waitFor(timeoutSeconds, TimeUnit.SECONDS)) {
                     process.destroy();
                     throw new IOException("Timeout waiting for cluster shutdown");
                 }
diff --git a/utils/cluster_manager.py b/utils/cluster_manager.py
index e5ea7ec51a..c647fa7898 100755
--- a/utils/cluster_manager.py
+++ b/utils/cluster_manager.py
@@ -61,7 +61,24 @@ def get_server_command() -> str:
     """Get server command, checking valkey-server first, then redis-server"""
     global _SERVER_COMMAND
     if _SERVER_COMMAND is None:
-        _SERVER_COMMAND = get_command(["valkey-server", "redis-server"])
+        # Check if ENGINE_PATH is set (for multi-engine setup)
+        engine_path = os.environ.get("ENGINE_PATH")
+        if engine_path:
+            # Try engine-specific binaries first
+            engine_valkey = f"{engine_path}/src/valkey-server"
+            engine_redis = f"{engine_path}/src/redis-server"
+
+            if os.path.exists(engine_valkey) and os.access(engine_valkey, os.X_OK):
+                _SERVER_COMMAND = engine_valkey
+            elif os.path.exists(engine_redis) and os.access(engine_redis, os.X_OK):
+                _SERVER_COMMAND = engine_redis
+            else:
+                raise Exception(
+                    f"No executable server binary found in {engine_path}/src/"
+                )
+        else:
+            # Fall back to PATH-based lookup
+            _SERVER_COMMAND = get_command(["valkey-server", "redis-server"])
     return _SERVER_COMMAND
 
 
@@ -69,7 +86,26 @@ def get_cli_command() -> str:
     """Get CLI command, checking valkey-cli first, then redis-cli"""
     global _CLI_COMMAND
     if _CLI_COMMAND is None:
-        _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
+        # Check if ENGINE_PATH is set (for multi-engine setup)
+        engine_path = os.environ.get("ENGINE_PATH")
+        if engine_path:
+            # Try engine-specific binaries first
+            engine_valkey_cli = f"{engine_path}/src/valkey-cli"
+            engine_redis_cli = f"{engine_path}/src/redis-cli"
+
+            if os.path.exists(engine_valkey_cli) and os.access(
+                engine_valkey_cli, os.X_OK
+            ):
+                _CLI_COMMAND = engine_valkey_cli
+            elif os.path.exists(engine_redis_cli) and os.access(
+                engine_redis_cli, os.X_OK
+            ):
+                _CLI_COMMAND = engine_redis_cli
+            else:
+                raise Exception(f"No executable CLI binary found in {engine_path}/src/")
+        else:
+            # Fall back to PATH-based lookup
+            _CLI_COMMAND = get_command(["valkey-cli", "redis-cli"])
     return _CLI_COMMAND
 
 
@@ -301,8 +337,13 @@ def print_servers_json(servers: List[Server]):
 
 
 def next_free_port(
-    min_port: int = 6379, max_port: int = 55535, timeout: int = 60
+    min_port: int = None, max_port: int = 55535, timeout: int = 60
 ) -> int:
+    # Use BASE_PORT from environment if set (for multi-engine setup)
+    if min_port is None:
+        base_port = os.environ.get("BASE_PORT")
+        min_port = int(base_port) if base_port else 6379
+
     tic = time.perf_counter()
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     timeout_start = time.time()
@@ -828,7 +869,7 @@ def is_address_already_in_use(
         if not os.path.exists(log_file):
             time.sleep(0.1)
             continue
-        
+
         with open(log_file, "r") as f:
             server_log = f.read()
             # Check for known error message variants because different C libraries

From 1c59d2e759d4c12199b359bf1a628c996dbb32bd Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:30:19 -0700
Subject: [PATCH 092/106] Fix semgrep and use powershell instead of pwsh

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 20 +++++++++----------
 .github/workflows/java.yml                    |  2 +-
 .github/workflows/setup-linux-runner.yml      |  4 +++-
 docs/REMOTE_CLUSTER_CREDENTIALS.md            |  4 +++-
 docs/REMOTE_CLUSTER_SETUP.md                  |  4 +++-
 docs/VPC_MULTI_ENGINE_SETUP.md                |  4 +++-
 docs/VPC_SETUP_GUIDE.md                       |  4 +++-
 utils/setup_vpc_pair.sh                       | 10 +++++++++-
 8 files changed, 35 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 620e9c2779..dee42d9ea2 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -69,8 +69,8 @@ runs:
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
         - name: Verify Rust toolchain (Windows)
-          shell: pwsh
-          if: "${{ inputs.os == 'windows' }}"
+          shell: powershell
+          if: "${{ runner.os == 'Windows' }}"
           run: |
               # Check if Rust is already available (may be pre-installed on self-hosted runners)
               try {
@@ -82,15 +82,15 @@ runs:
               }
 
         - name: Setup Python for Windows
-          if: "${{ inputs.os == 'windows' }}"
+          if: "${{ runner.os == 'Windows' }}"
           uses: actions/setup-python@v5
           with:
               python-version: "3.x"
 
         - name: Check Windows build dependencies
-          if: "${{ inputs.os == 'windows' }}"
+          if: "${{ runner.os == 'Windows' }}"
           id: check-deps
-          shell: pwsh
+          shell: powershell
           run: |
               Write-Host "Checking Windows build dependencies..."
 
@@ -139,8 +139,8 @@ runs:
               Write-Host "Dependency check complete"
 
         - name: Setup Python3 symlink (Windows)
-          if: "${{ inputs.os == 'windows' && steps.check-deps.outputs.python3-available == 'true' }}"
-          shell: pwsh
+          if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available == 'true' }}"
+          shell: powershell
           run: |
               # Create python3 symlink if python exists but python3 doesn't
               if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
@@ -154,8 +154,8 @@ runs:
               }
 
         - name: Verify Windows dependencies for remote cluster mode
-          if: "${{ inputs.os == 'windows' }}"
-          shell: pwsh
+          if: "${{ runner.os == 'Windows' }}"
+          shell: powershell
           run: |
               Write-Host "Verifying Windows dependencies for remote cluster + build..."
 
@@ -236,7 +236,7 @@ runs:
               sudo make install
 
         - name: Start engine server
-          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          shell: ${{ runner.os == 'Windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
           env:
               OS_TYPE: ${{ inputs.os }}
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index a8970ed241..e56b845ce4 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -350,7 +350,7 @@ jobs:
 
             - name: Setup networking and verify Valkey for PubSub (Windows)
               if: ${{ matrix.host.OS == 'windows' }}
-              shell: pwsh
+              shell: powershell
               run: |
                   # Optimize WSL for better performance (PubSub tests)
                   Write-Host "Optimizing WSL configuration for PubSub tests..."
diff --git a/.github/workflows/setup-linux-runner.yml b/.github/workflows/setup-linux-runner.yml
index 6a925910b1..079b50205a 100644
--- a/.github/workflows/setup-linux-runner.yml
+++ b/.github/workflows/setup-linux-runner.yml
@@ -34,8 +34,10 @@ jobs:
 
             - name: Setup Linux Runner
               id: setup
+              env:
+                  ACTION: ${{ github.event.inputs.action }}
               run: |
-                  case "${{ github.event.inputs.action }}" in
+                  case "$ACTION" in
                     "start")
                       echo "Starting Linux runner instance..."
                       
diff --git a/docs/REMOTE_CLUSTER_CREDENTIALS.md b/docs/REMOTE_CLUSTER_CREDENTIALS.md
index df55606ef6..e92a1027a2 100644
--- a/docs/REMOTE_CLUSTER_CREDENTIALS.md
+++ b/docs/REMOTE_CLUSTER_CREDENTIALS.md
@@ -69,7 +69,9 @@ VALKEY_REMOTE_HOST
 ssh -i your-key.pem ubuntu@<instance-ip>
 
 # Run setup script
-curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh | bash
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh -o setup_linux_runner.sh
+bash setup_linux_runner.sh
+rm setup_linux_runner.sh
 
 # Add public key to authorized_keys
 echo "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5... valkey-runner@github-actions" >> ~/.ssh/authorized_keys
diff --git a/docs/REMOTE_CLUSTER_SETUP.md b/docs/REMOTE_CLUSTER_SETUP.md
index 7918348ca1..2ecc02aae3 100644
--- a/docs/REMOTE_CLUSTER_SETUP.md
+++ b/docs/REMOTE_CLUSTER_SETUP.md
@@ -32,7 +32,9 @@ This document describes how to set up external Linux infrastructure for running
 
 # SSH to instance and run setup
 ssh -i your-key.pem ubuntu@<instance-ip>
-curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh | bash
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_linux_runner.sh -o setup_linux_runner.sh
+bash setup_linux_runner.sh
+rm setup_linux_runner.sh
 ```
 
 #### Option B: GitHub Workflow
diff --git a/docs/VPC_MULTI_ENGINE_SETUP.md b/docs/VPC_MULTI_ENGINE_SETUP.md
index 90b1fac00b..a01cc8af5b 100644
--- a/docs/VPC_MULTI_ENGINE_SETUP.md
+++ b/docs/VPC_MULTI_ENGINE_SETUP.md
@@ -41,7 +41,9 @@ This guide explains how to set up a VPC Linux instance with multiple Valkey/Redi
 **SSH to instance and run setup:**
 ```bash
 ssh -i your-key.pem ubuntu@<vpc-instance-ip>
-curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh | bash
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh -o setup_vpc_instance.sh
+bash setup_vpc_instance.sh
+rm setup_vpc_instance.sh
 ```
 
 ### 2. Configure GitHub Repository
diff --git a/docs/VPC_SETUP_GUIDE.md b/docs/VPC_SETUP_GUIDE.md
index 30273397cd..a740c0ec64 100644
--- a/docs/VPC_SETUP_GUIDE.md
+++ b/docs/VPC_SETUP_GUIDE.md
@@ -23,7 +23,9 @@ VPC: Your AWS VPC
 **SSH to your Linux instance and run:**
 ```bash
 # Download and run VPC setup script
-curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_pair.sh | bash
+curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_pair.sh -o setup_vpc_pair.sh
+bash setup_vpc_pair.sh
+rm setup_vpc_pair.sh
 ```
 
 This will:
diff --git a/utils/setup_vpc_pair.sh b/utils/setup_vpc_pair.sh
index fa2ac8b4cf..84c7844928 100755
--- a/utils/setup_vpc_pair.sh
+++ b/utils/setup_vpc_pair.sh
@@ -18,7 +18,15 @@ if [ -f /etc/os-release ] && grep -q "Ubuntu" /etc/os-release; then
     echo "Linux private IP: $LINUX_PRIVATE_IP"
     
     # Run the standard VPC setup
-    curl -sSL https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh | bash
+    SETUP_SCRIPT_URL="https://raw.githubusercontent.com/valkey-io/valkey-glide/main/utils/setup_vpc_instance.sh"
+    TEMP_SCRIPT=$(mktemp)
+    
+    echo "Downloading VPC setup script..."
+    curl -sSL "$SETUP_SCRIPT_URL" -o "$TEMP_SCRIPT"
+    
+    echo "Executing VPC setup script..."
+    bash "$TEMP_SCRIPT"
+    rm -f "$TEMP_SCRIPT"
     
     # Additional VPC-specific configuration
     echo "Configuring VPC-specific settings..."

From 0dd32a2d5b68ddd13ab3af63daa711ee294e5294 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:35:23 -0700
Subject: [PATCH 093/106] Fix powershell syntax error

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index dee42d9ea2..87273c080d 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -76,9 +76,9 @@ runs:
               try {
                   rustc --version
                   cargo --version
-                  Write-Host "✅ Rust toolchain already available"
+                  Write-Host "Rust toolchain already available"
               } catch {
-                  Write-Host "ℹ️ Rust toolchain not found - will be installed by install-rust-and-protoc action"
+                  Write-Host "Rust toolchain not found - will be installed by install-rust-and-protoc action"
               }
 
         - name: Setup Python for Windows

From bc52877bed539d1e3cce6321d8a5461b37f2be32 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:45:04 -0700
Subject: [PATCH 094/106] Fix more syntax issues

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/ISSUE_TEMPLATE/feature-request.yml    |  2 +-
 .github/workflows/dependabot-management.yml   |  2 +-
 .../install-shared-dependencies/action.yml    | 26 +++++------
 .../workflows/java-windows-self-hosted.yml    |  8 ++--
 .github/workflows/java.yml                    | 16 +++----
 .github/workflows/setup-linux-runner.yml      | 14 +++---
 utils/remote_cluster_manager.py               |  6 +--
 utils/setup_vpc_instance.sh                   |  4 +-
 utils/test_vpc_connectivity.py                | 44 +++++++++----------
 9 files changed, 63 insertions(+), 59 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
index a7607565aa..070b3b3dae 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -1,5 +1,5 @@
 ---
-name: 🚀 Feature Request
+name: Feature Request
 description: Suggest an idea for this project
 title: "(topic): (short issue description)"
 labels: [feature-request, needs-triage]
diff --git a/.github/workflows/dependabot-management.yml b/.github/workflows/dependabot-management.yml
index 8b259dff37..52e55551de 100644
--- a/.github/workflows/dependabot-management.yml
+++ b/.github/workflows/dependabot-management.yml
@@ -250,7 +250,7 @@ jobs:
                       }
 
                       // Add basic changelog information
-                      const changelog = `## Changelog\n\nUpdated ${depName} from ${fromVersion} to ${toVersion}\n\n📋 To view detailed changes, visit the package repository or release notes.`;
+                      const changelog = `## Changelog\n\nUpdated ${depName} from ${fromVersion} to ${toVersion}\n\n[INFO] To view detailed changes, visit the package repository or release notes.`;
                       
                       const newBody = `${body}\n\n${changelog}`;
                       
diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 87273c080d..500db13770 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -99,14 +99,14 @@ runs:
               try {
                   python3 --version
                   $python3Available = $true
-                  Write-Host "✅ Python3 already available"
+                  Write-Host "Python3 already available"
               } catch {
                   try {
                       python --version
-                      Write-Host "✅ Python available, will create python3 symlink"
+                      Write-Host "Python available, will create python3 symlink"
                       $python3Available = $true
                   } catch {
-                      Write-Host "❌ Python not found"
+                      Write-Host "Python not found"
                   }
               }
 
@@ -116,9 +116,9 @@ runs:
                   rustc --version
                   cargo --version
                   $rustAvailable = $true
-                  Write-Host "✅ Rust toolchain already available"
+                  Write-Host "Rust toolchain already available"
               } catch {
-                  Write-Host "ℹ️ Rust toolchain will be installed by install-rust-and-protoc action"
+                  Write-Host "Rust toolchain will be installed by install-rust-and-protoc action"
               }
 
               # Check SSH client
@@ -126,9 +126,9 @@ runs:
               try {
                   ssh -V 2>$null
                   $sshAvailable = $true
-                  Write-Host "✅ SSH client available"
+                  Write-Host "SSH client available"
               } catch {
-                  Write-Host "❌ SSH client not found"
+                  Write-Host "SSH client not found"
               }
 
               # Set outputs for conditional steps
@@ -149,7 +149,7 @@ runs:
                       $pythonPath = (Get-Command python).Source
                       $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
                       New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
-                      Write-Host "✅ python3 symlink created"
+                      Write-Host "python3 symlink created"
                   }
               }
 
@@ -161,17 +161,17 @@ runs:
 
               # Verify Python3 (required for remote_cluster_manager.py)
               python3 --version
-              Write-Host "✅ Python3 ready"
+              Write-Host "Python3 ready"
 
               # Verify SSH (required for remote cluster access)
               ssh -V
-              Write-Host "✅ SSH client ready"
+              Write-Host "SSH client ready"
 
               # Note: Rust and protoc will be installed by subsequent actions
-              Write-Host "ℹ️ Rust toolchain and protoc will be installed by install-rust-and-protoc action"
-              Write-Host "ℹ️ JDK will be installed by setup-java action"
+              Write-Host "Rust toolchain and protoc will be installed by install-rust-and-protoc action"
+              Write-Host "JDK will be installed by setup-java action"
 
-              Write-Host "✅ Windows ready for Java client build + remote cluster testing"
+              Write-Host "Windows ready for Java client build + remote cluster testing"
 
         - name: Cache Valkey build
           if: "${{ inputs.engine-version != '' }}"
diff --git a/.github/workflows/java-windows-self-hosted.yml b/.github/workflows/java-windows-self-hosted.yml
index b76124c4ae..7a82e74ddb 100644
--- a/.github/workflows/java-windows-self-hosted.yml
+++ b/.github/workflows/java-windows-self-hosted.yml
@@ -57,7 +57,7 @@ jobs:
                       exit 0
                   fi
 
-                  echo "🔧 Configuring remote Valkey cluster access..."
+                  echo "[CONFIG] Configuring remote Valkey cluster access..."
 
                   # Set up SSH key from GitHub secret
                   mkdir -p ~/.ssh
@@ -80,13 +80,13 @@ jobs:
                   chmod 600 ~/.ssh/config
 
                   # Test SSH connection
-                  echo "🔍 Testing SSH connection..."
+                  echo "[TEST] Testing SSH connection..."
                   python3 utils/remote_cluster_manager.py test || {
-                      echo "❌ SSH connection test failed"
+                      echo "[FAIL] SSH connection test failed"
                       exit 1
                   }
 
-                  echo "✅ Remote cluster access configured successfully"
+                  echo "[OK] Remote cluster access configured successfully"
 
                   # Set environment variables for Gradle
                   echo "VALKEY_REMOTE_HOST=${{ vars.VALKEY_REMOTE_HOST }}" >> $GITHUB_ENV
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index e56b845ce4..e35a80188e 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -173,7 +173,7 @@ jobs:
               run: |
                   # Check configuration priority: VPC > Remote > Local
                   if [ -n "${{ vars.VALKEY_VPC_HOST }}" ]; then
-                      echo "🔧 Configuring VPC Valkey instance access..."
+                      echo "Configuring VPC Valkey instance access..."
                       
                       # Set up SSH key from GitHub secret
                       mkdir -p ~/.ssh
@@ -196,20 +196,20 @@ jobs:
                       chmod 600 ~/.ssh/config
                       
                       # Test SSH connection
-                      echo "🔍 Testing VPC SSH connection..."
+                      echo "Testing VPC SSH connection..."
                       ssh -i ~/.ssh/valkey_vpc_key ubuntu@${{ vars.VALKEY_VPC_HOST }} "echo 'VPC connection successful'" || {
-                          echo "❌ VPC SSH connection failed"
+                          echo "VPC SSH connection failed"
                           exit 1
                       }
                       
-                      echo "✅ VPC Valkey instance configured successfully"
+                      echo "VPC Valkey instance configured successfully"
                       
                       # Set environment variables for Gradle
                       echo "VALKEY_VPC_HOST=${{ vars.VALKEY_VPC_HOST }}" >> $GITHUB_ENV
                       echo "SSH_PRIVATE_KEY_CONTENT=${{ secrets.VALKEY_VPC_SSH_KEY }}" >> $GITHUB_ENV
                       
                   elif [ -n "${{ vars.VALKEY_REMOTE_HOST }}" ]; then
-                      echo "🔧 Configuring remote Valkey cluster access..."
+                      echo "Configuring remote Valkey cluster access..."
                       
                       # Set up SSH key from GitHub secret
                       mkdir -p ~/.ssh
@@ -232,13 +232,13 @@ jobs:
                       chmod 600 ~/.ssh/config
                       
                       # Test SSH connection
-                      echo "🔍 Testing SSH connection..."
+                      echo "Testing SSH connection..."
                       python3 utils/remote_cluster_manager.py test || {
-                          echo "❌ SSH connection test failed"
+                          echo "SSH connection test failed"
                           exit 1
                       }
                       
-                      echo "✅ Remote cluster access configured successfully"
+                      echo "Remote cluster access configured successfully"
                       
                       # Set environment variables for Gradle
                       echo "VALKEY_REMOTE_HOST=${{ vars.VALKEY_REMOTE_HOST }}" >> $GITHUB_ENV
diff --git a/.github/workflows/setup-linux-runner.yml b/.github/workflows/setup-linux-runner.yml
index 079b50205a..b6429df3e7 100644
--- a/.github/workflows/setup-linux-runner.yml
+++ b/.github/workflows/setup-linux-runner.yml
@@ -36,6 +36,8 @@ jobs:
               id: setup
               env:
                   ACTION: ${{ github.event.inputs.action }}
+                  INSTANCE_TYPE: ${{ github.event.inputs.instance_type }}
+                  KEY_NAME: ${{ secrets.AWS_KEY_PAIR_NAME }}
               run: |
                   case "$ACTION" in
                     "start")
@@ -64,8 +66,8 @@ jobs:
                       # Launch instance
                       INSTANCE_ID=$(aws ec2 run-instances \
                         --image-id ami-0c02fb55956c7d316 \
-                        --instance-type ${{ github.event.inputs.instance_type }} \
-                        --key-name ${{ secrets.AWS_KEY_PAIR_NAME }} \
+                        --instance-type "$INSTANCE_TYPE" \
+                        --key-name "$KEY_NAME" \
                         --security-groups valkey-runner-sg \
                         --user-data file://<(cat << 'EOF'
                       #!/bin/bash
@@ -136,12 +138,14 @@ jobs:
 
             - name: Save runner info
               if: github.event.inputs.action == 'start'
+              env:
+                  RUNNER_IP: ${{ steps.setup.outputs.runner-ip }}
               run: |
                   echo "Linux runner started successfully!"
-                  echo "IP Address: ${{ steps.setup.outputs.runner-ip }}"
+                  echo "IP Address: $RUNNER_IP"
                   echo ""
                   echo "To use this runner in Windows tests, set environment variable:"
-                  echo "VALKEY_REMOTE_HOST=${{ steps.setup.outputs.runner-ip }}"
+                  echo "VALKEY_REMOTE_HOST=$RUNNER_IP"
                   echo ""
                   echo "SSH access:"
-                  echo "ssh -i ~/.ssh/your-key.pem ubuntu@${{ steps.setup.outputs.runner-ip }}"
+                  echo "ssh -i ~/.ssh/your-key.pem ubuntu@$RUNNER_IP"
diff --git a/utils/remote_cluster_manager.py b/utils/remote_cluster_manager.py
index c3f93a4d5a..1c635ea44a 100755
--- a/utils/remote_cluster_manager.py
+++ b/utils/remote_cluster_manager.py
@@ -116,7 +116,7 @@ def setup_remote_environment(self) -> bool:
 
         # Test connection first
         if not self.test_connection():
-            print("❌ SSH connection failed")
+            print("[FAIL] SSH connection failed")
             return False
 
         # Check if repo exists, clone if not
@@ -317,10 +317,10 @@ def main():
 
         if args.command == "test":
             if manager.test_connection():
-                print("✅ SSH connection successful")
+                print("[OK] SSH connection successful")
                 return 0
             else:
-                print("❌ SSH connection failed")
+                print("[FAIL] SSH connection failed")
                 return 1
 
         elif args.command == "start":
diff --git a/utils/setup_vpc_instance.sh b/utils/setup_vpc_instance.sh
index f7527ea00b..da65c35c9f 100755
--- a/utils/setup_vpc_instance.sh
+++ b/utils/setup_vpc_instance.sh
@@ -126,9 +126,9 @@ sudo systemctl start valkey-multi-engine
 echo "Testing engine installations..."
 for engine in valkey-7.2 valkey-8.0 valkey-8.1 redis-6.2 redis-7.0 redis-7.2; do
     if [ -f "/opt/engines/$engine/src/redis-server" ] || [ -f "/opt/engines/$engine/src/valkey-server" ]; then
-        echo "✅ $engine: installed"
+        echo "[OK] $engine: installed"
     else
-        echo "❌ $engine: failed to build"
+        echo "[FAIL] $engine: failed to build"
     fi
 done
 
diff --git a/utils/test_vpc_connectivity.py b/utils/test_vpc_connectivity.py
index 9dc61cb313..0fff860b9e 100755
--- a/utils/test_vpc_connectivity.py
+++ b/utils/test_vpc_connectivity.py
@@ -23,16 +23,16 @@ def test_ssh_connection(host: str, user: str = "ubuntu", key_path: str = None) -
     try:
         result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=15)
         if result.returncode == 0 and "SSH connection successful" in result.stdout:
-            print("✅ SSH connection successful")
+            print("[OK] SSH connection successful")
             return True
         else:
-            print(f"❌ SSH connection failed: {result.stderr}")
+            print(f"[FAIL] SSH connection failed: {result.stderr}")
             return False
     except subprocess.TimeoutExpired:
-        print("❌ SSH connection timed out")
+        print("[FAIL] SSH connection timed out")
         return False
     except Exception as e:
-        print(f"❌ SSH connection error: {e}")
+        print(f"[FAIL] SSH connection error: {e}")
         return False
 
 
@@ -49,12 +49,12 @@ def test_port_connectivity(host: str, ports: List[int]) -> List[Tuple[int, bool]
             sock.close()
 
             success = result == 0
-            status = "✅ Open" if success else "❌ Closed"
+            status = "[OK] Open" if success else "[FAIL] Closed"
             print(f"  Port {port}: {status}")
             results.append((port, success))
 
         except Exception as e:
-            print(f"  Port {port}: ❌ Error - {e}")
+            print(f"  Port {port}: [FAIL] Error - {e}")
             results.append((port, False))
 
     return results
@@ -77,17 +77,17 @@ def test_multi_engine_manager(host: str, key_path: str = None) -> bool:
     try:
         result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=30)
         if result.returncode == 0:
-            print("✅ Multi-engine manager working")
+            print("[OK] Multi-engine manager working")
             print("Available engines:")
             for line in result.stdout.strip().split("\n"):
                 if line.strip():
                     print(f"  {line}")
             return True
         else:
-            print(f"❌ Multi-engine manager failed: {result.stderr}")
+            print(f"[FAIL] Multi-engine manager failed: {result.stderr}")
             return False
     except Exception as e:
-        print(f"❌ Multi-engine manager error: {e}")
+        print(f"[FAIL] Multi-engine manager error: {e}")
         return False
 
 
@@ -117,10 +117,10 @@ def get_instance_info(host: str, key_path: str = None) -> dict:
                     info[key.strip()] = value.strip()
             return info
         else:
-            print(f"❌ Failed to get instance info: {result.stderr}")
+            print(f"[FAIL] Failed to get instance info: {result.stderr}")
             return {}
     except Exception as e:
-        print(f"❌ Instance info error: {e}")
+        print(f"[FAIL] Instance info error: {e}")
         return {}
 
 
@@ -138,31 +138,31 @@ def main():
 
     args = parser.parse_args()
 
-    print("🔍 VPC Connectivity Test for Valkey GLIDE")
+    print("[TEST] VPC Connectivity Test for Valkey GLIDE")
     print("=" * 50)
 
     # Test SSH connectivity
     ssh_ok = test_ssh_connection(args.linux_host, key_path=args.key_path)
     if not ssh_ok:
-        print("\n❌ SSH connectivity failed. Check:")
+        print("\n[FAIL] SSH connectivity failed. Check:")
         print("1. Security group allows SSH (port 22) from Windows instance")
         print("2. SSH key is correct")
         print("3. Linux instance is running")
         return 1
 
     # Get instance information
-    print("\n📋 Instance Information:")
+    print("\n[INFO] Instance Information:")
     info = get_instance_info(args.linux_host, key_path=args.key_path)
     for key, value in info.items():
         print(f"  {key}: {value}")
 
     # Test multi-engine manager
-    print("\n🔧 Multi-Engine Manager Test:")
+    print("\n[CONFIG] Multi-Engine Manager Test:")
     manager_ok = test_multi_engine_manager(args.linux_host, key_path=args.key_path)
 
     # Test port connectivity if requested
     if args.test_ports:
-        print("\n🔌 Port Connectivity Test:")
+        print("\n[PORT] Port Connectivity Test:")
         test_ports = [
             6379,  # valkey-7.2
             6479,  # valkey-8.0
@@ -175,17 +175,17 @@ def main():
 
         open_ports = [port for port, success in port_results if success]
         if open_ports:
-            print(f"✅ {len(open_ports)} ports accessible")
+            print(f"[OK] {len(open_ports)} ports accessible")
         else:
             print("⚠️ No Valkey ports currently open (clusters not running)")
 
     # Summary
-    print("\n📊 Test Summary:")
-    print(f"  SSH Connection: {'✅ Pass' if ssh_ok else '❌ Fail'}")
-    print(f"  Multi-Engine Manager: {'✅ Pass' if manager_ok else '❌ Fail'}")
+    print("\n[SUMMARY] Test Summary:")
+    print(f"  SSH Connection: {'[OK] Pass' if ssh_ok else '[FAIL] Fail'}")
+    print(f"  Multi-Engine Manager: {'[OK] Pass' if manager_ok else '[FAIL] Fail'}")
 
     if ssh_ok and manager_ok:
-        print("\n🎉 VPC connectivity test passed!")
+        print("\n[SUCCESS] VPC connectivity test passed!")
         print("\nNext steps:")
         print("1. Configure GitHub variables:")
         print(f"   VALKEY_VPC_HOST={args.linux_host}")
@@ -194,7 +194,7 @@ def main():
         print("3. Run Java tests with VPC instance")
         return 0
     else:
-        print("\n❌ VPC connectivity test failed!")
+        print("\n[FAIL] VPC connectivity test failed!")
         return 1
 
 

From 63ec4225ca5b1f0f7cbfdc4057f1307706a817d5 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 14:58:17 -0700
Subject: [PATCH 095/106] Fix incorrect attempt to run Valkey locally

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 28 +++++++++++++++++--
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 500db13770..e08046d391 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -236,12 +236,12 @@ runs:
               sudo make install
 
         - name: Start engine server
-          shell: ${{ runner.os == 'Windows' && 'wsl-bash {0}' || 'bash' }}
-          if: "${{ inputs.engine-version }}"
+          shell: bash
+          if: "${{ inputs.engine-version && !env.VALKEY_VPC_HOST && !env.VALKEY_REMOTE_HOST }}"
           env:
               OS_TYPE: ${{ inputs.os }}
           run: |
-              echo "Starting Valkey server"
+              echo "Starting Valkey server locally"
               echo "OS_TYPE: '$OS_TYPE'"
 
               # Start Valkey server in background
@@ -252,6 +252,28 @@ runs:
                   hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
               fi
 
+        - name: Test remote Valkey connectivity
+          shell: bash
+          if: "${{ inputs.engine-version && (env.VALKEY_VPC_HOST || env.VALKEY_REMOTE_HOST) }}"
+          run: |
+              echo "Testing remote Valkey connectivity..."
+
+              # Determine target host
+              if [ -n "$VALKEY_VPC_HOST" ]; then
+                  TARGET_HOST="$VALKEY_VPC_HOST"
+                  echo "Testing VPC Valkey at: $TARGET_HOST"
+              elif [ -n "$VALKEY_REMOTE_HOST" ]; then
+                  TARGET_HOST="$VALKEY_REMOTE_HOST"
+                  echo "Testing remote Valkey at: $TARGET_HOST"
+              fi
+
+              # Test basic connectivity (port 6379)
+              if timeout 10 bash -c "</dev/tcp/$TARGET_HOST/6379"; then
+                  echo "[OK] Valkey port 6379 is accessible"
+              else
+                  echo "[INFO] Valkey not yet started on $TARGET_HOST:6379 (will be started by cluster manager)"
+              fi
+
         - name: Install Rust toolchain and protoc
           if: "${{ !contains(inputs.target, 'musl') }}"
           uses: ./.github/workflows/install-rust-and-protoc

From 135f6ec9c9b554cd2d1c28fde1c0e1952532cac7 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:02:54 -0700
Subject: [PATCH 096/106] Fix python detection

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../workflows/install-shared-dependencies/action.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index e08046d391..fb75425eee 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -81,12 +81,6 @@ runs:
                   Write-Host "Rust toolchain not found - will be installed by install-rust-and-protoc action"
               }
 
-        - name: Setup Python for Windows
-          if: "${{ runner.os == 'Windows' }}"
-          uses: actions/setup-python@v5
-          with:
-              python-version: "3.x"
-
         - name: Check Windows build dependencies
           if: "${{ runner.os == 'Windows' }}"
           id: check-deps
@@ -138,6 +132,12 @@ runs:
 
               Write-Host "Dependency check complete"
 
+        - name: Setup Python for Windows
+          if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available != 'true' }}"
+          uses: actions/setup-python@v5
+          with:
+              python-version: "3.x"
+
         - name: Setup Python3 symlink (Windows)
           if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available == 'true' }}"
           shell: powershell

From 7aa6eefbf3c335824e87a1b56937134eb39e5b58 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:06:55 -0700
Subject: [PATCH 097/106] Python checking

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index fb75425eee..f59f3abb7e 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -88,20 +88,23 @@ runs:
           run: |
               Write-Host "Checking Windows build dependencies..."
 
+              # Debug: Show PATH and available Python commands
+              Write-Host "PATH contains:"
+              $env:PATH -split ';' | Where-Object { $_ -like '*python*' -or $_ -like '*Python*' } | ForEach-Object { Write-Host "  $_" }
+
+              Write-Host "Available Python commands:"
+              Get-Command python* -ErrorAction SilentlyContinue | ForEach-Object { Write-Host "  $($_.Name) -> $($_.Source)" }
+
               # Check Python3
               $python3Available = $false
-              try {
-                  python3 --version
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
                   $python3Available = $true
                   Write-Host "Python3 already available"
-              } catch {
-                  try {
-                      python --version
-                      Write-Host "Python available, will create python3 symlink"
-                      $python3Available = $true
-                  } catch {
-                      Write-Host "Python not found"
-                  }
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  Write-Host "Python available, will create python3 symlink"
+                  $python3Available = $true
+              } else {
+                  Write-Host "Python not found"
               }
 
               # Check Rust (should be installed by install-rust-and-protoc action)

From 11a6b9e06f1c7fa55ed3348d3e338b44549db69e Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:09:50 -0700
Subject: [PATCH 098/106] Fix Windows trying to run valkey locally

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/install-shared-dependencies/action.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index f59f3abb7e..f608239345 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -240,7 +240,7 @@ runs:
 
         - name: Start engine server
           shell: bash
-          if: "${{ inputs.engine-version && !env.VALKEY_VPC_HOST && !env.VALKEY_REMOTE_HOST }}"
+          if: "${{ inputs.engine-version && inputs.os != 'windows' }}"
           env:
               OS_TYPE: ${{ inputs.os }}
           run: |
@@ -257,7 +257,7 @@ runs:
 
         - name: Test remote Valkey connectivity
           shell: bash
-          if: "${{ inputs.engine-version && (env.VALKEY_VPC_HOST || env.VALKEY_REMOTE_HOST) }}"
+          if: "${{ inputs.engine-version && inputs.os == 'windows' }}"
           run: |
               echo "Testing remote Valkey connectivity..."
 

From c7a5dc0d66362067088e74518c6a0bd85bd6c435 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:15:00 -0700
Subject: [PATCH 099/106] Python detection

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../workflows/install-shared-dependencies/action.yml | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index f608239345..a4435ae71b 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -134,9 +134,19 @@ runs:
               echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
 
               Write-Host "Dependency check complete"
+              Write-Host "Results: python3-available=$python3Available, rust-available=$rustAvailable, ssh-available=$sshAvailable"
+
+        - name: Show Python detection results
+          if: "${{ runner.os == 'Windows' }}"
+          shell: powershell
+          run: |
+              Write-Host "Python detection results:"
+              Write-Host "  python3-available: ${{ steps.check-deps.outputs.python3-available }}"
+              Write-Host "  Runner type: ${{ runner.name }}"
+              Write-Host "  Will install Python: ${{ runner.os == 'Windows' && !contains(runner.name, 'self-hosted') && steps.check-deps.outputs.python3-available != 'true' }}"
 
         - name: Setup Python for Windows
-          if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available != 'true' }}"
+          if: "${{ runner.os == 'Windows' && !contains(runner.name, 'self-hosted') && steps.check-deps.outputs.python3-available != 'true' }}"
           uses: actions/setup-python@v5
           with:
               python-version: "3.x"

From 1261672fe36a80138262e83d8422621500658960 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:27:21 -0700
Subject: [PATCH 100/106] Python detection

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 58 ++++++++++++++++---
 1 file changed, 50 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index a4435ae71b..c486357372 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -97,14 +97,54 @@ runs:
 
               # Check Python3
               $python3Available = $false
+
+              # Method 1: Check for python3 command
               if (Get-Command python3 -ErrorAction SilentlyContinue) {
                   $python3Available = $true
-                  Write-Host "Python3 already available"
-              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
-                  Write-Host "Python available, will create python3 symlink"
-                  $python3Available = $true
-              } else {
-                  Write-Host "Python not found"
+                  Write-Host "Python3 command found"
+              }
+              # Method 2: Check for python command  
+              elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  try {
+                      $version = python --version 2>&1
+                      if ($version -match "Python 3\.") {
+                          $python3Available = $true
+                          Write-Host "Python 3.x found via python command: $version"
+                      } else {
+                          Write-Host "Python found but not version 3.x: $version"
+                      }
+                  } catch {
+                      Write-Host "Python command exists but version check failed"
+                  }
+              }
+              # Method 3: Check common installation paths
+              else {
+                  $commonPaths = @(
+                      "$env:LOCALAPPDATA\Programs\Python\Python*\python.exe",
+                      "$env:PROGRAMFILES\Python*\python.exe",
+                      "$env:PROGRAMFILES(x86)\Python*\python.exe",
+                      "C:\Python*\python.exe"
+                  )
+                  
+                  foreach ($path in $commonPaths) {
+                      $found = Get-ChildItem $path -ErrorAction SilentlyContinue | Select-Object -First 1
+                      if ($found) {
+                          try {
+                              $version = & $found.FullName --version 2>&1
+                              if ($version -match "Python 3\.") {
+                                  $python3Available = $true
+                                  Write-Host "Python 3.x found at: $($found.FullName) - $version"
+                                  break
+                              }
+                          } catch {
+                              Write-Host "Found Python at $($found.FullName) but version check failed"
+                          }
+                      }
+                  }
+              }
+
+              if (-not $python3Available) {
+                  Write-Host "No Python 3.x installation detected"
               }
 
               # Check Rust (should be installed by install-rust-and-protoc action)
@@ -143,10 +183,12 @@ runs:
               Write-Host "Python detection results:"
               Write-Host "  python3-available: ${{ steps.check-deps.outputs.python3-available }}"
               Write-Host "  Runner type: ${{ runner.name }}"
-              Write-Host "  Will install Python: ${{ runner.os == 'Windows' && !contains(runner.name, 'self-hosted') && steps.check-deps.outputs.python3-available != 'true' }}"
+              Write-Host "  Runner environment: ${{ runner.environment }}"
+              Write-Host "  Is GitHub-hosted: ${{ runner.environment == 'github-hosted' }}"
+              Write-Host "  Will install Python: ${{ runner.os == 'Windows' && runner.environment == 'github-hosted' && steps.check-deps.outputs.python3-available != 'true' }}"
 
         - name: Setup Python for Windows
-          if: "${{ runner.os == 'Windows' && !contains(runner.name, 'self-hosted') && steps.check-deps.outputs.python3-available != 'true' }}"
+          if: "${{ runner.os == 'Windows' && runner.environment == 'github-hosted' && steps.check-deps.outputs.python3-available != 'true' }}"
           uses: actions/setup-python@v5
           with:
               python-version: "3.x"

From 25c1092076f03d685e98d088f2e8b0e5e197a38b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:32:23 -0700
Subject: [PATCH 101/106] Python differs on Windows

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index c486357372..a6a40ee113 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -194,18 +194,23 @@ runs:
               python-version: "3.x"
 
         - name: Setup Python3 symlink (Windows)
-          if: "${{ runner.os == 'Windows' && steps.check-deps.outputs.python3-available == 'true' }}"
+          if: "${{ runner.os == 'Windows' }}"
           shell: powershell
           run: |
-              # Create python3 symlink if python exists but python3 doesn't
+              # Check if python3 command exists
               if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
+                  # Check if python command exists
                   if (Get-Command python -ErrorAction SilentlyContinue) {
                       Write-Host "Creating python3 symlink..."
                       $pythonPath = (Get-Command python).Source
                       $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
                       New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
                       Write-Host "python3 symlink created"
+                  } else {
+                      Write-Host "No Python installation found for symlink creation"
                   }
+              } else {
+                  Write-Host "python3 command already exists"
               }
 
         - name: Verify Windows dependencies for remote cluster mode
@@ -215,8 +220,16 @@ runs:
               Write-Host "Verifying Windows dependencies for remote cluster + build..."
 
               # Verify Python3 (required for remote_cluster_manager.py)
-              python3 --version
-              Write-Host "Python3 ready"
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  python3 --version
+                  Write-Host "Python3 ready"
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  python --version
+                  Write-Host "Python ready (using python command)"
+              } else {
+                  Write-Host "No Python found"
+                  exit 1
+              }
 
               # Verify SSH (required for remote cluster access)
               ssh -V

From 07df38c5fd8f5ef67f1e7463922a02c82ddc692a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:37:32 -0700
Subject: [PATCH 102/106] More python detection

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index a6a40ee113..2987b2698c 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -95,6 +95,54 @@ runs:
               Write-Host "Available Python commands:"
               Get-Command python* -ErrorAction SilentlyContinue | ForEach-Object { Write-Host "  $($_.Name) -> $($_.Source)" }
 
+              # Check Windows registry for Python installations
+              Write-Host "Checking Windows registry for Python..."
+              $regPaths = @(
+                  "HKLM:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                  "HKCU:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                  "HKLM:\SOFTWARE\WOW6432Node\Python\PythonCore\*\InstallPath"
+              )
+
+              foreach ($regPath in $regPaths) {
+                  try {
+                      Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
+                          $installPath = $_.'(default)'
+                          if ($installPath -and (Test-Path $installPath)) {
+                              Write-Host "  Registry: $installPath"
+                              $pythonExe = Join-Path $installPath "python.exe"
+                              if (Test-Path $pythonExe) {
+                                  Write-Host "    Found: $pythonExe"
+                              }
+                          }
+                      }
+                  } catch { }
+              }
+
+              # Check common installation directories
+              Write-Host "Checking common Python installation paths..."
+              $commonPaths = @(
+                  "$env:LOCALAPPDATA\Programs\Python\Python*",
+                  "$env:PROGRAMFILES\Python*",
+                  "$env:PROGRAMFILES(x86)\Python*",
+                  "C:\Python*",
+                  "$env:APPDATA\Local\Programs\Python\Python*"
+              )
+
+              foreach ($pathPattern in $commonPaths) {
+                  Get-ChildItem $pathPattern -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+                      $pythonExe = Join-Path $_.FullName "python.exe"
+                      if (Test-Path $pythonExe) {
+                          Write-Host "  Found: $pythonExe"
+                          try {
+                              $version = & $pythonExe --version 2>&1
+                              Write-Host "    Version: $version"
+                          } catch {
+                              Write-Host "    Version check failed"
+                          }
+                      }
+                  }
+              }
+
               # Check Python3
               $python3Available = $false
 

From e45a5ea28cf3039fc2d6fd45c0d2628050db439d Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:39:53 -0700
Subject: [PATCH 103/106] Move windows workflow into its own github action

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../install-shared-dependencies/action.yml    |  15 +-
 .../setup-windows-dependencies/action.yml     | 150 ++++++++++++++++++
 2 files changed, 154 insertions(+), 11 deletions(-)
 create mode 100644 .github/workflows/setup-windows-dependencies/action.yml

diff --git a/.github/workflows/install-shared-dependencies/action.yml b/.github/workflows/install-shared-dependencies/action.yml
index 2987b2698c..08ddabcf42 100644
--- a/.github/workflows/install-shared-dependencies/action.yml
+++ b/.github/workflows/install-shared-dependencies/action.yml
@@ -68,18 +68,11 @@ runs:
           run: |
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
-        - name: Verify Rust toolchain (Windows)
-          shell: powershell
+        - name: Setup Windows dependencies
           if: "${{ runner.os == 'Windows' }}"
-          run: |
-              # Check if Rust is already available (may be pre-installed on self-hosted runners)
-              try {
-                  rustc --version
-                  cargo --version
-                  Write-Host "Rust toolchain already available"
-              } catch {
-                  Write-Host "Rust toolchain not found - will be installed by install-rust-and-protoc action"
-              }
+          uses: ./.github/workflows/setup-windows-dependencies
+          with:
+              github-token: ${{ inputs.github-token }}
 
         - name: Check Windows build dependencies
           if: "${{ runner.os == 'Windows' }}"
diff --git a/.github/workflows/setup-windows-dependencies/action.yml b/.github/workflows/setup-windows-dependencies/action.yml
new file mode 100644
index 0000000000..576d65bea8
--- /dev/null
+++ b/.github/workflows/setup-windows-dependencies/action.yml
@@ -0,0 +1,150 @@
+name: "Setup Windows Dependencies"
+description: "Setup Python, SSH, and other Windows-specific dependencies"
+
+inputs:
+    github-token:
+        description: "GitHub token for authentication"
+        required: false
+        default: ${{ github.token }}
+
+outputs:
+    python-available:
+        description: "Whether Python is available"
+        value: ${{ steps.check.outputs.python-available }}
+    ssh-available:
+        description: "Whether SSH is available"
+        value: ${{ steps.check.outputs.ssh-available }}
+
+runs:
+    using: "composite"
+    steps:
+        - name: Check Windows dependencies
+          id: check
+          shell: powershell
+          run: |
+              Write-Host "Checking Windows dependencies..."
+
+              # Check for Python installations
+              $pythonAvailable = $false
+              $pythonPath = $null
+
+              # Method 1: Check PATH commands
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  $pythonAvailable = $true
+                  $pythonPath = (Get-Command python3).Source
+                  Write-Host "Found python3 in PATH: $pythonPath"
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  $version = python --version 2>&1
+                  if ($version -match "Python 3\.") {
+                      $pythonAvailable = $true
+                      $pythonPath = (Get-Command python).Source
+                      Write-Host "Found Python 3.x via python command: $version"
+                  }
+              }
+
+              # Method 2: Check registry if not found in PATH
+              if (-not $pythonAvailable) {
+                  Write-Host "Checking Windows registry for Python..."
+                  $regPaths = @(
+                      "HKLM:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                      "HKCU:\SOFTWARE\Python\PythonCore\*\InstallPath",
+                      "HKLM:\SOFTWARE\WOW6432Node\Python\PythonCore\*\InstallPath"
+                  )
+
+                  foreach ($regPath in $regPaths) {
+                      Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
+                          $installPath = $_.'(default)'
+                          if ($installPath -and (Test-Path $installPath)) {
+                              $pythonExe = Join-Path $installPath "python.exe"
+                              if (Test-Path $pythonExe) {
+                                  $version = & $pythonExe --version 2>&1
+                                  if ($version -match "Python 3\.") {
+                                      $pythonAvailable = $true
+                                      $pythonPath = $pythonExe
+                                      Write-Host "Found Python 3.x in registry: $pythonExe ($version)"
+                                      break
+                                  }
+                              }
+                          }
+                      }
+                      if ($pythonAvailable) { break }
+                  }
+              }
+
+              # Method 3: Check common paths if still not found
+              if (-not $pythonAvailable) {
+                  Write-Host "Checking common installation paths..."
+                  $commonPaths = @(
+                      "$env:LOCALAPPDATA\Programs\Python\Python*",
+                      "$env:PROGRAMFILES\Python*",
+                      "$env:PROGRAMFILES(x86)\Python*",
+                      "C:\Python*"
+                  )
+
+                  foreach ($pathPattern in $commonPaths) {
+                      Get-ChildItem $pathPattern -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+                          $pythonExe = Join-Path $_.FullName "python.exe"
+                          if (Test-Path $pythonExe) {
+                              $version = & $pythonExe --version 2>&1
+                              if ($version -match "Python 3\.") {
+                                  $pythonAvailable = $true
+                                  $pythonPath = $pythonExe
+                                  Write-Host "Found Python 3.x at: $pythonExe ($version)"
+                                  break
+                              }
+                          }
+                      }
+                      if ($pythonAvailable) { break }
+                  }
+              }
+
+              # Check SSH
+              $sshAvailable = $false
+              if (Get-Command ssh -ErrorAction SilentlyContinue) {
+                  $sshAvailable = $true
+                  Write-Host "SSH client available"
+              } else {
+                  Write-Host "SSH client not found"
+              }
+
+              # Set outputs
+              echo "python-available=$pythonAvailable" >> $env:GITHUB_OUTPUT
+              echo "ssh-available=$sshAvailable" >> $env:GITHUB_OUTPUT
+
+              Write-Host "Detection complete: Python=$pythonAvailable, SSH=$sshAvailable"
+
+        - name: Setup Python3 symlink
+          if: steps.check.outputs.python-available == 'true'
+          shell: powershell
+          run: |
+              if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
+                  if (Get-Command python -ErrorAction SilentlyContinue) {
+                      Write-Host "Creating python3 symlink..."
+                      $pythonPath = (Get-Command python).Source
+                      $python3Path = Join-Path (Split-Path $pythonPath) "python3.exe"
+                      New-Item -ItemType HardLink -Path $python3Path -Target $pythonPath -Force
+                      Write-Host "python3 symlink created"
+                  }
+              } else {
+                  Write-Host "python3 command already exists"
+              }
+
+        - name: Install Python (GitHub-hosted only)
+          if: runner.environment == 'github-hosted' && steps.check.outputs.python-available != 'true'
+          uses: actions/setup-python@v5
+          with:
+              python-version: "3.x"
+
+        - name: Verify Python setup
+          shell: powershell
+          run: |
+              if (Get-Command python3 -ErrorAction SilentlyContinue) {
+                  python3 --version
+                  Write-Host "Python3 ready"
+              } elseif (Get-Command python -ErrorAction SilentlyContinue) {
+                  python --version
+                  Write-Host "Python ready"
+              } else {
+                  Write-Host "No Python available"
+                  exit 1
+              }

From ed63752be0e697a4a5cefb3c3ad7a6f7fab70b8f Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:46:19 -0700
Subject: [PATCH 104/106] python detection debugging

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../setup-windows-dependencies/action.yml     | 98 +++++++++++++++----
 1 file changed, 79 insertions(+), 19 deletions(-)

diff --git a/.github/workflows/setup-windows-dependencies/action.yml b/.github/workflows/setup-windows-dependencies/action.yml
index 576d65bea8..2d6720cd1f 100644
--- a/.github/workflows/setup-windows-dependencies/action.yml
+++ b/.github/workflows/setup-windows-dependencies/action.yml
@@ -24,27 +24,62 @@ runs:
           run: |
               Write-Host "Checking Windows dependencies..."
 
+              # Debug: Show current PATH
+              Write-Host "Current PATH:"
+              $env:PATH -split ';' | ForEach-Object { Write-Host "  $_" }
+
+              # Debug: Show all executables that might be Python
+              Write-Host "All python-like executables in PATH:"
+              Get-Command python*, py -ErrorAction SilentlyContinue | ForEach-Object { 
+                  Write-Host "  $($_.Name) -> $($_.Source)"
+                  try {
+                      $version = & $_.Source --version 2>&1
+                      Write-Host "    Version: $version"
+                  } catch {
+                      Write-Host "    Version check failed: $_"
+                  }
+              }
+
               # Check for Python installations
               $pythonAvailable = $false
               $pythonPath = $null
 
               # Method 1: Check PATH commands
+              Write-Host "Method 1: Checking PATH commands..."
               if (Get-Command python3 -ErrorAction SilentlyContinue) {
                   $pythonAvailable = $true
                   $pythonPath = (Get-Command python3).Source
                   Write-Host "Found python3 in PATH: $pythonPath"
               } elseif (Get-Command python -ErrorAction SilentlyContinue) {
                   $version = python --version 2>&1
+                  Write-Host "Found python command, version: $version"
                   if ($version -match "Python 3\.") {
                       $pythonAvailable = $true
                       $pythonPath = (Get-Command python).Source
                       Write-Host "Found Python 3.x via python command: $version"
+                  } else {
+                      Write-Host "Python found but not version 3.x: $version"
                   }
+              } elseif (Get-Command py -ErrorAction SilentlyContinue) {
+                  Write-Host "Found py launcher, checking version..."
+                  try {
+                      $version = py --version 2>&1
+                      Write-Host "py launcher version: $version"
+                      if ($version -match "Python 3\.") {
+                          $pythonAvailable = $true
+                          $pythonPath = (Get-Command py).Source
+                          Write-Host "Found Python 3.x via py launcher: $version"
+                      }
+                  } catch {
+                      Write-Host "py launcher version check failed: $_"
+                  }
+              } else {
+                  Write-Host "No python commands found in PATH"
               }
 
               # Method 2: Check registry if not found in PATH
               if (-not $pythonAvailable) {
-                  Write-Host "Checking Windows registry for Python..."
+                  Write-Host "Method 2: Checking Windows registry for Python..."
                   $regPaths = @(
                       "HKLM:\SOFTWARE\Python\PythonCore\*\InstallPath",
                       "HKCU:\SOFTWARE\Python\PythonCore\*\InstallPath",
@@ -52,20 +87,36 @@ runs:
                   )
 
                   foreach ($regPath in $regPaths) {
-                      Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
-                          $installPath = $_.'(default)'
-                          if ($installPath -and (Test-Path $installPath)) {
-                              $pythonExe = Join-Path $installPath "python.exe"
-                              if (Test-Path $pythonExe) {
-                                  $version = & $pythonExe --version 2>&1
-                                  if ($version -match "Python 3\.") {
-                                      $pythonAvailable = $true
-                                      $pythonPath = $pythonExe
-                                      Write-Host "Found Python 3.x in registry: $pythonExe ($version)"
-                                      break
+                      Write-Host "Checking registry path: $regPath"
+                      try {
+                          Get-ItemProperty $regPath -ErrorAction SilentlyContinue | ForEach-Object {
+                              $installPath = $_.'(default)'
+                              Write-Host "Registry entry found: $installPath"
+                              if ($installPath -and (Test-Path $installPath)) {
+                                  $pythonExe = Join-Path $installPath "python.exe"
+                                  Write-Host "Checking: $pythonExe"
+                                  if (Test-Path $pythonExe) {
+                                      try {
+                                          $version = & $pythonExe --version 2>&1
+                                          Write-Host "Found Python at $pythonExe - Version: $version"
+                                          if ($version -match "Python 3\.") {
+                                              $pythonAvailable = $true
+                                              $pythonPath = $pythonExe
+                                              Write-Host "Using Python 3.x from registry: $pythonExe"
+                                              break
+                                          }
+                                      } catch {
+                                          Write-Host "Version check failed for $pythonExe : $_"
+                                      }
+                                  } else {
+                                      Write-Host "python.exe not found at: $pythonExe"
                                   }
+                              } else {
+                                  Write-Host "Install path does not exist: $installPath"
                               }
                           }
+                      } catch {
+                          Write-Host "Registry check failed for $regPath : $_"
                       }
                       if ($pythonAvailable) { break }
                   }
@@ -73,7 +124,7 @@ runs:
 
               # Method 3: Check common paths if still not found
               if (-not $pythonAvailable) {
-                  Write-Host "Checking common installation paths..."
+                  Write-Host "Method 3: Checking common installation paths..."
                   $commonPaths = @(
                       "$env:LOCALAPPDATA\Programs\Python\Python*",
                       "$env:PROGRAMFILES\Python*",
@@ -82,16 +133,25 @@ runs:
                   )
 
                   foreach ($pathPattern in $commonPaths) {
+                      Write-Host "Checking pattern: $pathPattern"
                       Get-ChildItem $pathPattern -Directory -ErrorAction SilentlyContinue | ForEach-Object {
                           $pythonExe = Join-Path $_.FullName "python.exe"
+                          Write-Host "Checking: $pythonExe"
                           if (Test-Path $pythonExe) {
-                              $version = & $pythonExe --version 2>&1
-                              if ($version -match "Python 3\.") {
-                                  $pythonAvailable = $true
-                                  $pythonPath = $pythonExe
-                                  Write-Host "Found Python 3.x at: $pythonExe ($version)"
-                                  break
+                              try {
+                                  $version = & $pythonExe --version 2>&1
+                                  Write-Host "Found Python at $pythonExe - Version: $version"
+                                  if ($version -match "Python 3\.") {
+                                      $pythonAvailable = $true
+                                      $pythonPath = $pythonExe
+                                      Write-Host "Using Python 3.x from common path: $pythonExe"
+                                      break
+                                  }
+                              } catch {
+                                  Write-Host "Version check failed for $pythonExe : $_"
                               }
+                          } else {
+                              Write-Host "python.exe not found at: $pythonExe"
                           }
                       }
                       if ($pythonAvailable) { break }

From c792f691cdfedf24f84ecfedd2d37df80b72036c Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 15:50:51 -0700
Subject: [PATCH 105/106] Python detection

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .github/workflows/setup-windows-dependencies/action.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/setup-windows-dependencies/action.yml b/.github/workflows/setup-windows-dependencies/action.yml
index 2d6720cd1f..a573a2484c 100644
--- a/.github/workflows/setup-windows-dependencies/action.yml
+++ b/.github/workflows/setup-windows-dependencies/action.yml
@@ -189,8 +189,8 @@ runs:
                   Write-Host "python3 command already exists"
               }
 
-        - name: Install Python (GitHub-hosted only)
-          if: runner.environment == 'github-hosted' && steps.check.outputs.python-available != 'true'
+        - name: Install Python (when missing)
+          if: steps.check.outputs.python-available != 'true'
           uses: actions/setup-python@v5
           with:
               python-version: "3.x"

From 4d44bbcaa61bb26fd57bb1442fceceb72bb7998c Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Wed, 29 Oct 2025 16:00:43 -0700
Subject: [PATCH 106/106] Fix Python installation

Signed-off-by: James Duong <duong.james@gmail.com>
---
 .../setup-windows-dependencies/action.yml     | 25 ++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/setup-windows-dependencies/action.yml b/.github/workflows/setup-windows-dependencies/action.yml
index a573a2484c..3dfd69c737 100644
--- a/.github/workflows/setup-windows-dependencies/action.yml
+++ b/.github/workflows/setup-windows-dependencies/action.yml
@@ -191,9 +191,28 @@ runs:
 
         - name: Install Python (when missing)
           if: steps.check.outputs.python-available != 'true'
-          uses: actions/setup-python@v5
-          with:
-              python-version: "3.x"
+          shell: powershell
+          run: |
+              Write-Host "Installing Python 3.11..."
+
+              # Download Python installer
+              $pythonUrl = "https://www.python.org/ftp/python/3.11.7/python-3.11.7-amd64.exe"
+              $installerPath = "$env:TEMP\python-installer.exe"
+
+              Write-Host "Downloading Python installer..."
+              Invoke-WebRequest -Uri $pythonUrl -OutFile $installerPath
+
+              Write-Host "Installing Python (current user only)..."
+              # Install for current user only, add to PATH
+              Start-Process -FilePath $installerPath -ArgumentList "/quiet", "InstallAllUsers=0", "PrependPath=1", "Include_test=0" -Wait
+
+              Write-Host "Cleaning up installer..."
+              Remove-Item $installerPath -Force
+
+              Write-Host "Refreshing PATH..."
+              $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH", "User") + ";" + [System.Environment]::GetEnvironmentVariable("PATH", "Machine")
+
+              Write-Host "Python installation complete"
 
         - name: Verify Python setup
           shell: powershell