test: Windows .cmd-shim discovery probe for #149

Add a manual workflow_dispatch probe (win-opencode-probe.yml) + a Windows-gated
ignored Rust test that answers, deterministically on windows-latest, whether the
dashboard's discovery path can execute a pnpm/npm .cmd shim directly or needs
cmd /C. The Rust probe uses the real run_bounded_binary (same tokio Command the
code uses) on a temp opencode.cmd and prints raw outcomes; a pwsh step reproduces
the real pnpm-global layout and probes the actual shim via CreateProcessW vs
cmd /C. CI has full PATH, so this isolates the .cmd-execution mechanism (not the
GUI PATH-inheritance angle, which a shell-launched runner can't reproduce).

No behavior change; exploratory probe before implementing the fix.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

.github/workflows/win-opencode-probe.yml

@@ -0,0 +1,70 @@
+name: Windows opencode discovery probe
+
+# Manual, exploratory probe for #149 (pnpm/npm `.cmd` shim discovery on Windows).
+# It answers one question deterministically: can the dashboard's discovery path
+# execute a `.cmd` shim, or does it need `cmd /C`? CI runs with a full PATH, so
+# it CANNOT reproduce the GUI PATH-inheritance angle — only the .cmd-execution
+# mechanism, which is the part we need to confirm before fixing.
+on:
+  workflow_dispatch:
+
+jobs:
+  probe:
+    name: Probe .cmd shim execution
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+
+      # --- Faithful probe: uses the dashboard crate's REAL tokio::process::Command
+      #     path via run_bounded_binary, and prints raw outcomes. ---
+      - name: Rust probe (real discovery path on a temp .cmd)
+        working-directory: packages/dashboard/src-tauri
+        run: cargo test win_cmd_shim_execution_probe -- --ignored --nocapture
+
+      # --- Real-world reproduction: a pnpm-global opencode, exactly like #149. ---
+      - name: Install opencode via pnpm (reproduce #149 layout)
+        shell: pwsh
+        continue-on-error: true
+        run: |
+          npm install -g pnpm
+          pnpm add -g opencode-ai
+          Write-Host "PNPM_HOME=$env:PNPM_HOME"
+          Write-Host "LOCALAPPDATA=$env:LOCALAPPDATA"
+          Write-Host "--- pnpm dir contents ---"
+          Get-ChildItem -Recurse -Filter "opencode*" "$env:LOCALAPPDATA\pnpm" -ErrorAction SilentlyContinue | Select-Object FullName
+          Write-Host "--- where.exe opencode ---"
+          where.exe opencode
+
+      - name: Probe the real pnpm shim (direct vs cmd /C)
+        shell: pwsh
+        continue-on-error: true
+        run: |
+          # Resolve the pnpm shim the way discovery would, then try to launch it
+          # via CreateProcessW (UseShellExecute=$false — identical to Rust's
+          # Command) vs through cmd /C.
+          $shim = (where.exe opencode 2>$null | Select-Object -First 1)
+          if (-not $shim) { Write-Host "no opencode on PATH; skipping"; exit 0 }
+          Write-Host "resolved shim: $shim"
+
+          function Try-Launch($file, $arguments) {
+            $psi = New-Object System.Diagnostics.ProcessStartInfo
+            $psi.FileName = $file
+            $psi.Arguments = $arguments
+            $psi.UseShellExecute = $false   # CreateProcessW path, same as Rust Command
+            $psi.RedirectStandardOutput = $true
+            $psi.RedirectStandardError = $true
+            try {
+              $p = [System.Diagnostics.Process]::Start($psi)
+              $out = $p.StandardOutput.ReadToEnd()
+              $p.WaitForExit()
+              return "LAUNCHED exit=$($p.ExitCode) out=$($out.Trim())"
+            } catch {
+              return "FAILED: $($_.Exception.Message)"
+            }
+          }
+
+          Write-Host "[direct] $(Try-Launch $shim '--version')"
+          Write-Host "[cmd /C] $(Try-Launch 'cmd.exe' "/C `"$shim`" --version")"

packages/dashboard/src-tauri/src/commands.rs

@@ -1425,6 +1425,75 @@ mod tests {
         );
     }
 
+    // Exploratory probe for #149: can the dashboard's discovery path execute a
+    // pnpm/npm `.cmd` shim at all? Rust's Command (like every CreateProcessW
+    // caller) does not run batch files directly, so a resolved `opencode.cmd`
+    // may fail to launch even when discovery FINDS it. Run on Windows CI with:
+    //   cargo test --ignored --nocapture win_cmd_shim_execution_probe
+    // It prints the raw outcomes; the fix is then asserted by a real regression
+    // test once the mechanism is confirmed.
+    #[cfg(windows)]
+    #[tokio::test]
+    #[ignore = "manual Windows discovery probe; run with --ignored --nocapture"]
+    async fn win_cmd_shim_execution_probe() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let shim = dir.path().join("opencode.cmd");
+        std::fs::write(&shim, "@echo off\r\necho probe-opencode 9.9.9\r\n").expect("write shim");
+        let shim_str = shim.to_string_lossy().to_string();
+        println!("\n[probe] shim at: {shim_str}");
+
+        // 1. What the REAL discovery path does: run_bounded_binary(<.cmd>, ...).
+        //    It swallows the launch error, so a None here means "could not run".
+        let via_helper = run_bounded_binary(&shim_str, &["--version"]).await;
+        println!("[probe] run_bounded_binary(.cmd) -> {via_helper:?}");
+
+        // 2. Raw Command on the .cmd to expose the actual OS error kind.
+        let raw = tokio::process::Command::new(&shim_str)
+            .arg("--version")
+            .output()
+            .await;
+        match &raw {
+            Ok(o) => println!(
+                "[probe] raw Command(.cmd): launched status={} stdout={:?}",
+                o.status,
+                String::from_utf8_lossy(&o.stdout).trim()
+            ),
+            Err(e) => println!(
+                "[probe] raw Command(.cmd): FAILED kind={:?} msg={e}",
+                e.kind()
+            ),
+        }
+
+        // 3. The proposed fix path: cmd /C <.cmd>.
+        let via_cmd = tokio::process::Command::new("cmd")
+            .args(["/C", &shim_str, "--version"])
+            .output()
+            .await;
+        match &via_cmd {
+            Ok(o) => println!(
+                "[probe] cmd /C .cmd: launched status={} stdout={:?}",
+                o.status,
+                String::from_utf8_lossy(&o.stdout).trim()
+            ),
+            Err(e) => println!("[probe] cmd /C .cmd: FAILED {e}"),
+        }
+
+        // 4. where.exe sanity: CI has full PATH, so this isolates the failure to
+        //    execution rather than discovery (the GUI PATH-inheritance angle of
+        //    #149 cannot be reproduced in a shell-launched CI runner).
+        let where_out = tokio::process::Command::new("where.exe")
+            .arg("cmd")
+            .output()
+            .await;
+        println!(
+            "[probe] where.exe cmd -> {:?}",
+            where_out
+                .ok()
+                .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        );
+        println!("[probe] done\n");
+    }
+
     #[test]
     fn test_parse_pi_models_output_normal() {
         let input = "provider        model                           context  max-out  thinking  images\nanthropic       claude-opus-4-5                 200K     64K      yes       yes   \ncerebras        gpt-oss-120b                    131.1K   32.8K    yes       no    \ngithub-copilot  claude-opus-4.7                 144K     64K      yes       yes   \n";