codex-grok-bridge 1.0.5 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## Unreleased
+
+## 1.5.0 — 2026-09-12
+
+First cut that accepts **Windows** (`"os": ["darwin", "linux", "win32"]`).
+
+- Isolated win32 wrapper under `%LOCALAPPDATA%\codex-grok-bridge`. Never writes WindowsApps.
+- Launch reads a Store ChatGPT / `resources/codex.exe` pointer when the isolated copies are missing.
+- Grok 4.7 drop prep: any `grok-*` id uses the Grok provider. Extra catalog slugs via `GROK_BRIDGE_MODELS`.
+- UTM Windows 11 ARM64 guest: Node 22.23.2, `node --test` 157/0/3 on 1.5.0, official ChatGPT ARM64 MSIX `OpenAI.Codex_26.903.8094.0`, bundled CLI `codex-cli 0.153.4`, grok 1.0.25, loopback `/v1/models` 200. See `docs/windows-arm64-guest.md`.
+
+Install: `npm install -g codex-grok-bridge@1.5.0`
+
 ## 1.0.5 — 2026-09-12
 
 First npm cut that accepts **Linux** (`"os": ["darwin", "linux"]`). Windows stays rejected.

package/README.md

@@ -11,10 +11,10 @@ Codex UI/CLI → app-server → scripts/codex-wrapper.mjs (adds grok-4.6 to the
              → Codex executes every tool call; results return as the next input
 ```
 
-The published npm package installs on **macOS and Linux** (`"os": ["darwin",
-"linux"]`). Windows installs are rejected by npm. The official ChatGPT/Codex
-`.deb` stays untouched; `scripts/install-codex-grok-app.sh` writes a separate
-wrapper.
+The published npm package installs on **macOS, Linux, and Windows** (`"os":
+["darwin", "linux", "win32"]`) starting at 1.5.0. Official ChatGPT/Codex
+prefixes stay untouched; `scripts/install-codex-grok-app.sh` and
+`scripts/install-codex-grok-app.ps1` write a separate wrapper.
 
 
 ---
@@ -29,18 +29,20 @@ The bridge does **not** execute Grok-native tools. It translates Codex tools int
 function calling, streams the upstream Responses events, and rewrites names back
 so Codex still recognizes them.
 
-Thirteen files under `src/`. Zero runtime dependencies. Node.js ≥ 22.
+Fourteen files under `src/`. Zero runtime dependencies. Node.js ≥ 22.
 
-This is not a second-opinion review product, not a Grok 4.7 adapter, and not a
-Grok-native search product. If Codex exposes a web-search tool, Grok can call
+This is not a second-opinion review product and not a Grok-native search
+product. New Grok ids, including 4.7 when the CLI lists them, use the same
+`grok-*` route. Set `GROK_BRIDGE_MODELS=grok-4.7` to show extras in the catalog
+before they are the default. If Codex exposes a web-search tool, Grok can call
 that tool the same way it calls any other Codex tool.
 
 ## Requirements
 
-- macOS, or Linux with the official ChatGPT/Codex desktop package
+- macOS, Linux, or Windows 11 with the official ChatGPT/Codex desktop package
 - Node.js ≥ 22
-- `/Applications/Codex.app` (macOS) or `/usr/lib/chatgpt/ChatGPT` (Linux)
-- `grok` CLI at `~/.grok/bin/grok`
+- `/Applications/Codex.app` (macOS), `/usr/lib/chatgpt/ChatGPT` (Linux), or the official ChatGPT MSIX (Windows)
+- `grok` CLI at `~/.grok/bin/grok` (Windows: `%USERPROFILE%\.grok\bin\grok.exe`)
 - a completed `grok login`
 
 The `.command` launcher resolves paths from its own location, so moving the
@@ -56,7 +58,7 @@ re-verification.
 ### Terminal (npm)
 
 ```sh
-npm install -g codex-grok-bridge   # macOS or Linux, Node ≥ 22
+npm install -g codex-grok-bridge   # macOS, Linux, or Windows; Node ≥ 22
 codex-grok                         # launches Codex with Grok 4.6 available
 codex-grok exec --skip-git-repo-check --sandbox workspace-write 'your task'
 ```
@@ -69,7 +71,7 @@ starts, and tears the provider down with that process.
 ```sh
 git clone https://github.com/deximple/codex-grok-bridge.git
 cd codex-grok-bridge
-npm test                        # 150 tests, no network, no inference
+npm test                        # 160 tests, no network, no inference
 node scripts/codex-grok.mjs
 ```
 
@@ -79,7 +81,8 @@ Double-click **Open Codex with Grok.command** in this folder, or keep a
 **separate** desktop wrapper in sync with
 `scripts/install-codex-grok-app.sh` (see [Desktop install and update](#desktop-install-and-update)).
 On Linux that wrapper is `~/.local/share/codex-grok-bridge/app` plus a user
-`.desktop` entry; the stock `/usr/lib/chatgpt` tree is not patched.
+`.desktop` entry; the stock `/usr/lib/chatgpt` tree is not patched. On Windows
+it is `%LOCALAPPDATA%\codex-grok-bridge`; `WindowsApps` is never written.
 
 In the new Codex window, **select Grok 4.6 / xAI before starting a new
 thread**. Existing GPT models stay on the list. A Codex window that was already
@@ -277,13 +280,14 @@ Start here when something breaks. Do not open `~/.grok/auth.json` or
 | `GROK_BRIDGE_TRANSPORT=fetch` | Use Node `fetch` instead of `node:http(s)` |
 | `GROK_BRIDGE_INFERENCE=cli` | Fall back to the CLI envelope path |
 | `GROK_BRIDGE_DIAGNOSTICS=off` | Do not write the JSONL log |
+| `GROK_BRIDGE_MODELS` | Extra `grok-*` catalog ids (comma or space), e.g. `grok-4.7` |
 | `NODE` | Absolute `node` binary for the `.command` launcher / desktop scripts |
-| `CODEX_GROK_APP` | Alternate app path for `install-codex-grok-app.sh` (macOS: `/Applications/Codex Grok.app`; Linux: `~/.local/share/codex-grok-bridge/app`) |
+| `CODEX_GROK_APP` | Alternate app path for the desktop installer (macOS: `/Applications/Codex Grok.app`; Linux: `~/.local/share/codex-grok-bridge/app`; Windows: `%LOCALAPPDATA%\codex-grok-bridge\app`) |
 
 ## Verify
 
 ```sh
-npm test                    # 150 tests, no remote inference
+npm test                    # 160 tests, no remote inference
 npm run test:coverage       # 80% line / branch / function gate
 npm run verify:app-server   # real app-server routing; also runs against an installed bundle
 npm audit --omit=dev
@@ -298,6 +302,7 @@ inference. A live CLI check spends the user’s quota.
 ```sh
 sh scripts/install-codex-grok-app.sh          # sync bridge JS only (default)
 sh scripts/install-codex-grok-app.sh --full   # macOS: rebuild and sign the launcher applet
+powershell -File scripts/install-codex-grok-app.ps1
 ```
 
 The default copies this checkout’s `src/` and `scripts/*.mjs` into the bundle,
@@ -310,7 +315,10 @@ On macOS the script updates an existing `Codex Grok.app`. It does not create
 one, and it does not touch `/Applications/Codex.app`. On Linux it creates
 `~/.local/share/codex-grok-bridge/app` and
 `~/.local/share/applications/codex-grok.desktop`, and it does not write
-`/usr/lib/chatgpt` or `/usr/share/applications/chatgpt.desktop`.
+`/usr/lib/chatgpt` or `/usr/share/applications/chatgpt.desktop`. On Windows
+`scripts/install-codex-grok-app.ps1` writes
+`%LOCALAPPDATA%\codex-grok-bridge` and may point at a Store `ChatGPT.exe` /
+`resources\codex.exe`; it never writes `WindowsApps`.
 
 ## Security notes
 
@@ -348,18 +356,20 @@ Grok 4.6을 Codex 모델 목록에 넣고, Codex의 `/v1/responses`를
 calling으로 옮기고, 상류 Responses 스트림을 전달한 뒤, Codex가 알아보는
 이름으로 되돌립니다.
 
-`src/` 아래 파일 13개. 런타임 의존성 없음. Node.js 22 이상.
+`src/` 아래 파일 14개. 런타임 의존성 없음. Node.js 22 이상. 1.5.0부터 npm
+`"os"`는 `darwin` / `linux` / `win32`입니다.
 
-코드 리뷰 전용 제품이 아니고, Grok 4.7 어댑터도 아니며, Grok 네이티브 검색
-제품도 아닙니다. Codex가 웹 검색 도구를 노출하면 Grok은 다른 Codex 도구와 같이
-그 도구를 호출할 수 있습니다.
+코드 리뷰 전용 제품이 아니고 Grok 네이티브 검색 제품도 아닙니다. CLI가 새
+id(4.7 포함)를 내놓으면 같은 `grok-*` 경로로 붙습니다. 기본 카탈로그에 먼저
+보이게 하려면 `GROK_BRIDGE_MODELS=grok-4.7`을 씁니다. Codex가 웹 검색 도구를
+노출하면 Grok은 다른 Codex 도구와 같이 그 도구를 호출할 수 있습니다.
 
 ## 필요한 것
 
-- macOS, 또는 공식 ChatGPT/Codex 데스크톱 패키지가 있는 Linux
+- macOS, Linux, 또는 공식 ChatGPT/Codex 데스크톱이 있는 Windows 11
 - Node.js 22 이상
-- `/Applications/Codex.app` (macOS) 또는 `/usr/lib/chatgpt/ChatGPT` (Linux)
-- `~/.grok/bin/grok`
+- `/Applications/Codex.app` (macOS), `/usr/lib/chatgpt/ChatGPT` (Linux), 또는 공식 ChatGPT MSIX (Windows)
+- `~/.grok/bin/grok` (Windows: `%USERPROFILE%\.grok\bin\grok.exe`)
 - 완료된 `grok login`
 
 `.command` 런처는 자기 위치를 기준으로 경로를 잡으므로 폴더를 옮겨도 수정할
@@ -374,7 +384,7 @@ calling으로 옮기고, 상류 Responses 스트림을 전달한 뒤, Codex가
 ### 터미널 (npm)
 
 ```sh
-npm install -g codex-grok-bridge   # macOS or Linux, Node ≥ 22
+npm install -g codex-grok-bridge   # macOS, Linux, Windows; Node ≥ 22
 codex-grok                         # Grok 4.6이 있는 Codex를 띄움
 codex-grok exec --skip-git-repo-check --sandbox workspace-write '작업 내용'
 ```
@@ -387,7 +397,7 @@ codex-grok exec --skip-git-repo-check --sandbox workspace-write '작업 내용'
 ```sh
 git clone https://github.com/deximple/codex-grok-bridge.git
 cd codex-grok-bridge
-npm test                        # 150건, 네트워크·추론 없음
+npm test                        # 160건, 네트워크·추론 없음
 node scripts/codex-grok.mjs
 ```
 
@@ -397,7 +407,8 @@ node scripts/codex-grok.mjs
 `scripts/install-codex-grok-app.sh`로 **별도의** 데스크톱 래퍼를 체크아웃과
 맞춥니다([데스크톱 설치와 갱신](#데스크톱-설치와-갱신)).
 Linux에서는 `~/.local/share/codex-grok-bridge/app`과 사용자 `.desktop`이고,
-정품 `/usr/lib/chatgpt`는 패치하지 않습니다.
+정품 `/usr/lib/chatgpt`는 패치하지 않습니다. Windows에서는
+`%LOCALAPPDATA%\codex-grok-bridge`이고 `WindowsApps`는 쓰지 않습니다.
 
 새로 열린 Codex 창에서 **새 작업을 시작하기 전에 Grok 4.6 / xAI를 선택**하세요.
 기존 GPT 모델도 목록에 남습니다. 이미 열려 있던 일반 Codex 창에는 이 확장이
@@ -584,13 +595,14 @@ provider에 Codex `request_max_retries` / `stream_max_retries`를 2로 두어
 | `GROK_BRIDGE_TRANSPORT=fetch` | `node:http(s)` 대신 Node `fetch` |
 | `GROK_BRIDGE_INFERENCE=cli` | CLI 봉투 경로로 폴백 |
 | `GROK_BRIDGE_DIAGNOSTICS=off` | JSONL 로그를 쓰지 않음 |
+| `GROK_BRIDGE_MODELS` | 카탈로그에 더할 `grok-*` id (쉼표/공백). 예: `grok-4.7` |
 | `NODE` | `.command` / 데스크톱 스크립트가 쓸 `node` 절대 경로 |
-| `CODEX_GROK_APP` | `install-codex-grok-app.sh`가 쓸 앱 경로 (macOS: `/Applications/Codex Grok.app`; Linux: `~/.local/share/codex-grok-bridge/app`) |
+| `CODEX_GROK_APP` | 데스크톱 설치기가 쓸 앱 경로 (macOS: `/Applications/Codex Grok.app`; Linux: `~/.local/share/codex-grok-bridge/app`; Windows: `%LOCALAPPDATA%\codex-grok-bridge\app`) |
 
 ## 검증
 
 ```sh
-npm test                    # 150건, 외부 추론 없음
+npm test                    # 160건, 외부 추론 없음
 npm run test:coverage       # line/branch/function 80% 게이트
 npm run verify:app-server   # 실제 app-server 라우팅. 설치된 앱 번들에서도 실행
 npm audit --omit=dev
@@ -605,6 +617,7 @@ CLI 검증은 사용자 계정 사용량을 씁니다.
 ```sh
 sh scripts/install-codex-grok-app.sh          # 브리지 JS만 동기화 (기본)
 sh scripts/install-codex-grok-app.sh --full   # macOS: 런처 applet 재빌드 + 서명
+powershell -File scripts/install-codex-grok-app.ps1
 ```
 
 기본 동작은 이 체크아웃의 `src/`와 `scripts/*.mjs`를 번들에 복사하고, 저장소에
@@ -615,7 +628,10 @@ sh scripts/install-codex-grok-app.sh --full   # macOS: 런처 applet 재빌드 +
 macOS에서는 이미 있는 `Codex Grok.app`을 갱신하며 `/Applications/Codex.app`은
 건드리지 않습니다. Linux에서는 `~/.local/share/codex-grok-bridge/app`과
 `~/.local/share/applications/codex-grok.desktop`을 만들고 `/usr/lib/chatgpt`와
-정품 `chatgpt.desktop`은 쓰지 않습니다.
+정품 `chatgpt.desktop`은 쓰지 않습니다. Windows에서는
+`scripts/install-codex-grok-app.ps1`이 `%LOCALAPPDATA%\codex-grok-bridge`를
+쓰고 Store `ChatGPT.exe` / `resources\codex.exe`를 가리킬 수 있으며,
+`WindowsApps`는 쓰지 않습니다.
 
 ## 보안
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-grok-bridge",
-  "version": "1.0.5",
+  "version": "1.5.0",
   "description": "Run Grok 4.6 as the model inside Codex, with Codex still owning tools, permissions, history and MCP. Uses the grok login session, not an API key.",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,8 @@
   },
   "os": [
     "darwin",
-    "linux"
+    "linux",
+    "win32"
   ],
   "bin": {
     "codex-grok": "scripts/codex-grok.mjs"
@@ -36,6 +37,7 @@
     "scripts/codex-grok.mjs",
     "scripts/codex-wrapper.mjs",
     "scripts/install-codex-grok-app.sh",
+    "scripts/install-codex-grok-app.ps1",
     "scripts/launch-desktop.mjs",
     "Open Codex with Grok.command",
     "README.md",

package/scripts/install-codex-grok-app.ps1

@@ -0,0 +1,67 @@
+# Install or update the dedicated Codex Grok desktop wrapper on Windows.
+# Writes %LOCALAPPDATA%\codex-grok-bridge\app only. Never writes WindowsApps.
+param(
+  [switch]$Force
+)
+
+$ErrorActionPreference = "Stop"
+$Root = Split-Path -Parent $PSScriptRoot
+$App = if ($env:CODEX_GROK_APP) { $env:CODEX_GROK_APP } else { Join-Path $env:LOCALAPPDATA "codex-grok-bridge\app" }
+$UserData = Join-Path $env:LOCALAPPDATA "codex-grok-bridge\desktop"
+
+if ($App -match "(?i)WindowsApps") {
+  Write-Error "refusing to install into the stock ChatGPT/Codex prefix: $App"
+}
+
+if (-not $Force) {
+  $hit = Get-CimInstance Win32_Process -ErrorAction SilentlyContinue |
+    Where-Object { $_.CommandLine -and $_.CommandLine -like "*--user-data-dir=$UserData*" }
+  if ($hit) {
+    Write-Error "Codex Grok is running. Close its window first, or pass -Force."
+  }
+}
+
+New-Item -ItemType Directory -Force -Path (Join-Path $App "scripts"), (Join-Path $App "src") | Out-Null
+Copy-Item (Join-Path $Root "scripts\*.mjs") (Join-Path $App "scripts") -Force
+Copy-Item (Join-Path $Root "src\*.mjs") (Join-Path $App "src") -Force
+
+$Node = if ($env:NODE) { $env:NODE } else { (Get-Command node -ErrorAction Stop).Source }
+$Launcher = Join-Path $App "codex-grok-desktop.cmd"
+@"
+@echo off
+set ROOT=%~dp0
+"$Node" "%ROOT%scripts\launch-desktop.mjs" %*
+"@ | Set-Content -Path $Launcher -Encoding ASCII
+
+$StartDir = Join-Path $env:APPDATA "Microsoft\Windows\Start Menu\Programs"
+New-Item -ItemType Directory -Force -Path $StartDir | Out-Null
+Copy-Item $Launcher (Join-Path $StartDir "Codex Grok.cmd") -Force
+
+function Write-StorePointer([string]$Name, [string[]]$Filters) {
+  $pointerDir = Split-Path -Parent $App
+  if ($pointerDir -match "(?i)WindowsApps") { return }
+  $pkgs = @(Get-AppxPackage -AllUsers -ErrorAction SilentlyContinue | Where-Object { $_.Name -match "OpenAI\.(ChatGPT|Codex)|ChatGPT" })
+  if (-not $pkgs) {
+    $pkgs = @(Get-AppxPackage -ErrorAction SilentlyContinue | Where-Object { $_.Name -match "OpenAI\.(ChatGPT|Codex)|ChatGPT" })
+  }
+  foreach ($filter in $Filters) {
+    foreach ($pkg in $pkgs) {
+      if (-not $pkg.InstallLocation) { continue }
+      $hits = @(Get-ChildItem -Path $pkg.InstallLocation -Filter $filter -Recurse -ErrorAction SilentlyContinue)
+      $hit = $hits | Where-Object { $_.FullName -match '\\resources\\codex\.exe$' } | Select-Object -First 1
+      if (-not $hit) { $hit = $hits | Select-Object -First 1 }
+      if (-not $hit) { continue }
+      New-Item -ItemType Directory -Force -Path $pointerDir | Out-Null
+      Set-Content -Path (Join-Path $pointerDir $Name) -Value $hit.FullName -Encoding ASCII
+      Write-Output "store pointer $Name=$($hit.FullName)"
+      return
+    }
+  }
+}
+
+Write-StorePointer "store-app.txt" @("ChatGPT.exe", "Codex.exe")
+Write-StorePointer "store-codex.txt" @("codex.exe")
+
+Write-Output "win32 wrapper $Launcher"
+Write-Output "bridge in $App matches $Root"
+Write-Output "restart any open Codex Grok window to load it"

package/scripts/install-codex-grok-app.sh

@@ -3,7 +3,8 @@
 #
 # macOS: sync JS into /Applications/Codex Grok.app (must already exist).
 # Linux: create ~/.local/share/codex-grok-bridge/app and a user .desktop.
-# Never writes /Applications/Codex.app or /usr/lib/chatgpt.
+# Windows: create %LOCALAPPDATA%\codex-grok-bridge\app and a Start Menu .cmd.
+# Never writes /Applications/Codex.app, /usr/lib/chatgpt, or WindowsApps.
 #
 #   install-codex-grok-app.sh            sync bridge JS (safe, fast)
 #   install-codex-grok-app.sh --full     macOS: rebuild applet; Linux: rewrite launcher
@@ -14,16 +15,24 @@
 set -eu
 
 ROOT="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)"
-USER_DATA="$HOME/.local/share/codex-grok-bridge/desktop"
 PLATFORM="${CODEX_GROK_PLATFORM:-$(uname -s)}"
 case "$PLATFORM" in
   Linux|linux) PLATFORM=linux ;;
   Darwin|darwin) PLATFORM=darwin ;;
+  MINGW*|MSYS*|CYGWIN*|Windows_NT|win32|windows) PLATFORM=win32 ;;
 esac
+if [ "$PLATFORM" = win32 ]; then
+  USER_DATA="${LOCALAPPDATA:-$HOME/AppData/Local}/codex-grok-bridge/desktop"
+else
+  USER_DATA="$HOME/.local/share/codex-grok-bridge/desktop"
+fi
 
 if [ "$PLATFORM" = linux ]; then
   APP="${CODEX_GROK_APP:-$HOME/.local/share/codex-grok-bridge/app}"
   BRIDGE="$APP"
+elif [ "$PLATFORM" = win32 ]; then
+  APP="${CODEX_GROK_APP:-${LOCALAPPDATA:-$HOME/AppData/Local}/codex-grok-bridge/app}"
+  BRIDGE="$APP"
 else
   APP="${CODEX_GROK_APP:-/Applications/Codex Grok.app}"
   BRIDGE="$APP/Contents/Resources/bridge"
@@ -41,18 +50,18 @@ for arg in "$@"; do
 done
 
 case "$APP" in
-  /usr/lib/chatgpt|/usr/lib/chatgpt/*|/usr/bin/chatgpt|/Applications/Codex.app|/Applications/Codex.app/*)
+  /usr/lib/chatgpt|/usr/lib/chatgpt/*|/usr/bin/chatgpt|/Applications/Codex.app|/Applications/Codex.app/*|*WindowsApps*|*windowsapps*)
     echo "refusing to install into the stock ChatGPT/Codex prefix: $APP" >&2
     exit 1
     ;;
 esac
 
-if [ "$PLATFORM" != linux ] && [ ! -d "$APP/Contents" ]; then
+if [ "$PLATFORM" != linux ] && [ "$PLATFORM" != win32 ] && [ ! -d "$APP/Contents" ]; then
   echo "missing $APP" >&2
   exit 1
 fi
 
-if [ "$FORCE" -eq 0 ] && pgrep -f -- "--user-data-dir=$USER_DATA" >/dev/null 2>&1; then
+if [ "$FORCE" -eq 0 ] && [ "$PLATFORM" != win32 ] && pgrep -f -- "--user-data-dir=$USER_DATA" >/dev/null 2>&1; then
   echo "Codex Grok is running. Close its window first, or pass --force to swap" >&2
   echo "the files under it (the running window keeps its loaded code either way)." >&2
   exit 1
@@ -120,8 +129,28 @@ EOF
   echo "desktop entry $DESKTOP"
 }
 
+write_win32_wrapper() {
+  NODE="${NODE:-$(command -v node || true)}"
+  [ -n "$NODE" ] || { echo "no node on PATH; set NODE=/path/to/node" >&2; exit 1; }
+  mkdir -p "$APP"
+  LAUNCHER="$APP/codex-grok-desktop.cmd"
+  NODE_WIN=$(printf "%s" "$NODE" | tr '/' '\\')
+  {
+    echo "@echo off"
+    echo "set ROOT=%~dp0"
+    echo "\"$NODE_WIN\" \"%ROOT%scripts\\launch-desktop.mjs\" %*"
+  } > "$LAUNCHER"
+  START_DIR="${APPDATA:-$HOME/AppData/Roaming}/Microsoft/Windows/Start Menu/Programs"
+  mkdir -p "$START_DIR"
+  cp "$LAUNCHER" "$START_DIR/Codex Grok.cmd"
+  echo "win32 wrapper $LAUNCHER"
+  echo "start menu $START_DIR/Codex Grok.cmd"
+}
+
 if [ "$PLATFORM" = linux ]; then
   write_linux_wrapper
+elif [ "$PLATFORM" = win32 ]; then
+  write_win32_wrapper
 elif [ "$FULL" -eq 1 ]; then
   NODE="${NODE:-$(command -v node || true)}"
   [ -n "$NODE" ] || { echo "no node on PATH; set NODE=/path/to/node" >&2; exit 1; }

package/scripts/launch-desktop.mjs

@@ -21,7 +21,28 @@ function log(message) {
   appendFileSync(logFile, `${new Date().toISOString()} ${message}\n`);
 }
 
+function grokPidWin32() {
+  const systemRoot = process.env.SystemRoot || "C:\\Windows";
+  const powershell = `${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+  try {
+    const out = execFileSync(
+      powershell,
+      [
+        "-NoProfile",
+        "-Command",
+        `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like ${JSON.stringify(`*--user-data-dir=${userData}*`)} } | Select-Object -First 1 -ExpandProperty ProcessId`,
+      ],
+      { encoding: "utf8", windowsHide: true, timeout: 15000 },
+    );
+    const pid = Number(String(out).trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
 function grokPid() {
+  if (platform === "win32") return grokPidWin32();
   const out = execFileSync("/bin/ps", ["-axo", "pid=,command="], {
     encoding: "utf8",
   });
@@ -53,6 +74,26 @@ function notify(text) {
   } catch {}
 }
 
+function startWin32(wrapper) {
+  const app = resolveDesktopApp();
+  log(`start win32 app=${app} wrapper=${wrapper}`);
+  const child = spawn(app, desktopLaunchArgs(userData), {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...desktopLaunchEnv({ wrapper, userData }),
+    },
+  });
+  child.on("error", (error) => {
+    log(`spawn failed: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    log(`chatgpt exit=${code}`);
+    process.exit(code ?? 1);
+  });
+}
+
 function startLinux(wrapper) {
   const app = resolveDesktopApp();
   const pathPrefix = `${path.dirname(process.execPath)}:/usr/local/bin:/usr/bin:/bin`;
@@ -127,6 +168,7 @@ try {
     }
   }
   if (platform === "linux") startLinux(wrapper);
+  else if (platform === "win32") startWin32(wrapper);
   else startDarwin(wrapper);
 } catch (error) {
   log(`fatal: ${error.message}`);

package/src/bridge.mjs

@@ -13,35 +13,9 @@ import { toProxyRequest } from "./tools.mjs";
 import { classifyBridgeError, errorSignature, bridgeErrorMessage } from "./errors.mjs";
 import { createDiagnostics } from "./diagnostics.mjs";
 import { createSlots } from "./slots.mjs";
+import { catalogModelInfos, isGrokModel, MODEL_INFO } from "./models.mjs";
 
-export const MODEL_INFO = {
-  slug: "grok-4.6",
-  display_name: "Grok 4.6 / xAI",
-  description: "Grok 4.6 via grok login; Codex executes tools",
-  default_reasoning_level: "high",
-  supported_reasoning_levels: ["low", "medium", "high", "xhigh"].map(
-    (effort) => ({ effort, description: effort }),
-  ),
-  shell_type: "unified_exec",
-  visibility: "list",
-  supported_in_api: true,
-  priority: 50,
-  availability_nux: null,
-  upgrade: null,
-  support_verbosity: false,
-  default_verbosity: null,
-  apply_patch_tool_type: "freeform",
-  truncation_policy: { mode: "tokens", limit: 10000 },
-  experimental_supported_tools: [],
-  context_window: 500000,
-  input_modalities: ["text", "image"],
-  tool_mode: "direct",
-  node_repl_disabled: true,
-  model_messages: {
-    instructions_template:
-      "You are Grok 4.6 by xAI, running as the Codex model. Use the tools provided by Codex and respect its permissions. Complete the user request accurately.",
-  },
-};
+export { MODEL_INFO };
 
 export function publicBridgeError(error, context = {}) {
   if (error instanceof GrokAuthError) return error.message;
@@ -69,7 +43,7 @@ export function createBridgeServer(options = {}) {
     };
     const route = new URL(req.url, "http://127.0.0.1").pathname;
     if (req.method === "GET" && route === "/v1/models")
-      return json(200, { models: [MODEL_INFO] });
+      return json(200, { models: catalogModelInfos() });
     if (req.method !== "POST" || route !== "/v1/responses")
       return json(404, { error: "Not found" });
     const auth = Buffer.from(req.headers.authorization ?? "");
@@ -95,7 +69,7 @@ export function createBridgeServer(options = {}) {
       }
       requestBytes = size;
       body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-      if (body?.model !== "grok-4.6" || !Array.isArray(body.input))
+      if (!isGrokModel(body?.model) || !Array.isArray(body.input))
         throw new Error();
     } catch {
       return json(400, { error: "Invalid request" });

package/src/cli-inference.mjs

@@ -5,6 +5,8 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir, homedir } from "node:os";
 import path from "node:path";
 import { toImageBlocks } from "./images.mjs";
+import { resolveGrokBinary } from "./paths.mjs";
+import { resolveGrokModel } from "./models.mjs";
 
 // The GROK_BRIDGE_INFERENCE=cli fallback. It drives the Grok CLI once per turn
 // with the whole Codex request as a prompt and parses a JSON envelope back out.
@@ -59,7 +61,7 @@ export function buildGrokInvocation(body, options = {}) {
     "--single",
     extractLatestUserPrompt(body.input),
     "--model",
-    "grok-4.6",
+    resolveGrokModel(body.model),
     "--output-format",
     "json",
     "--json-schema",
@@ -117,7 +119,7 @@ export function buildGrokInvocation(body, options = {}) {
     "You are a model backend for Codex. Return exactly the JSON envelope requested in the input. Do not execute your own tools. Tool calls in the envelope are executed by Codex.",
   ];
   return {
-    binary: options.grokBinary ?? path.join(homedir(), ".grok/bin/grok"),
+    binary: options.grokBinary ?? resolveGrokBinary(homedir()),
     args,
     // Run the CLI where Codex is working, not where the bridge happens to live.
     cwd:

package/src/models.mjs

@@ -0,0 +1,121 @@
+export const DEFAULT_GROK_MODEL = "grok-4.6";
+export const GROK_PROVIDER = "grok_build_cli";
+
+export function isGrokModel(model) {
+  return typeof model === "string" && model.startsWith("grok-");
+}
+
+export function resolveGrokModel(model) {
+  return isGrokModel(model) ? model : DEFAULT_GROK_MODEL;
+}
+
+export function grokDisplayName(id) {
+  return `Grok ${String(id).slice("grok-".length)}`;
+}
+
+export function extraGrokModels(env = process.env) {
+  const raw = env.GROK_BRIDGE_MODELS ?? "";
+  const seen = new Set();
+  const ids = [];
+  for (const part of raw.split(/[,\s]+/)) {
+    const id = part.trim();
+    if (!isGrokModel(id) || seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function catalogModelIds(env = process.env) {
+  const ids = [DEFAULT_GROK_MODEL];
+  const seen = new Set(ids);
+  for (const id of extraGrokModels(env)) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function parseGrokCliModels(text) {
+  const ids = [];
+  const seen = new Set();
+  for (const line of String(text).split(/\r?\n/)) {
+    const match = line.match(/^\s*[*+-]\s+(grok-[^\s(]+)/);
+    if (!match || seen.has(match[1])) continue;
+    seen.add(match[1]);
+    ids.push(match[1]);
+  }
+  return ids;
+}
+
+export function modelEntry(id = DEFAULT_GROK_MODEL) {
+  const label = grokDisplayName(id);
+  return {
+    id,
+    model: id,
+    displayName: `${label} / xAI`,
+    description: `${label} · Codex tools`,
+    hidden: false,
+    isDefault: false,
+    upgrade: null,
+    upgradeInfo: null,
+    availabilityNux: null,
+    supportedReasoningEfforts: ["low", "medium", "high", "xhigh"].map(
+      (reasoningEffort) => ({ reasoningEffort, description: reasoningEffort }),
+    ),
+    defaultReasoningEffort: "high",
+    inputModalities: ["text", "image"],
+    supportsPersonality: false,
+    multiAgentVersion: null,
+    additionalSpeedTiers: [],
+    serviceTiers: [],
+  };
+}
+
+export function modelInfo(id = DEFAULT_GROK_MODEL) {
+  const label = grokDisplayName(id);
+  return {
+    slug: id,
+    display_name: `${label} / xAI`,
+    description: `${label} via grok login; Codex executes tools`,
+    default_reasoning_level: "high",
+    supported_reasoning_levels: ["low", "medium", "high", "xhigh"].map(
+      (effort) => ({ effort, description: effort }),
+    ),
+    shell_type: "unified_exec",
+    visibility: "list",
+    supported_in_api: true,
+    priority: 50,
+    availability_nux: null,
+    upgrade: null,
+    support_verbosity: false,
+    default_verbosity: null,
+    apply_patch_tool_type: "freeform",
+    truncation_policy: { mode: "tokens", limit: 10000 },
+    experimental_supported_tools: [],
+    context_window: 500000,
+    input_modalities: ["text", "image"],
+    tool_mode: "direct",
+    node_repl_disabled: true,
+    model_messages: {
+      instructions_template:
+        `You are ${label} by xAI, running as the Codex model. Use the tools provided by Codex and respect its permissions. Complete the user request accurately.`,
+    },
+  };
+}
+
+export const MODEL_ENTRY = modelEntry();
+export const MODEL_INFO = modelInfo();
+
+export function catalogModelEntries(env = process.env) {
+  return catalogModelIds(env).map((id) =>
+    id === DEFAULT_GROK_MODEL ? MODEL_ENTRY : modelEntry(id),
+  );
+}
+
+export function catalogModelInfos(env = process.env) {
+  return catalogModelIds(env).map((id) =>
+    id === DEFAULT_GROK_MODEL ? MODEL_INFO : modelInfo(id),
+  );
+}

package/src/paths.mjs

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 
 export const LINUX_CODEX_BINARY = "/usr/lib/chatgpt/resources/codex";
@@ -6,29 +7,80 @@ export const LINUX_CHATGPT_BIN = "/usr/lib/chatgpt/ChatGPT";
 export const DARWIN_CODEX_BINARY = "/Applications/Codex.app/Contents/Resources/codex";
 export const DARWIN_CODEX_APP = "/Applications/Codex.app";
 export const LINUX_STOCK_PREFIX = "/usr/lib/chatgpt";
+export const WIN32_WINDOWSAPPS = "WindowsApps";
+export const WIN32_BRIDGE_APP = "codex-grok-bridge";
 
 export function resolvePlatform(options = {}) {
   const env = options.env ?? process.env;
   return options.platform ?? env.CODEX_GROK_PLATFORM ?? process.platform;
 }
 
+export function localAppData(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (env.LOCALAPPDATA) return env.LOCALAPPDATA;
+  return path.join(home, "AppData", "Local");
+}
+
+export function win32AppDir(home = homedir(), options = {}) {
+  return path.join(localAppData(home, options), WIN32_BRIDGE_APP, "app");
+}
+
+export function win32StorePointer(home = homedir(), options = {}, name = "store-app.txt") {
+  return path.join(localAppData(home, options), WIN32_BRIDGE_APP, name);
+}
+
+function readPointer(file, options = {}) {
+  const exists = options.existsSync ?? existsSync;
+  const read = options.readFileSync ?? ((p) => readFileSync(p, "utf8"));
+  if (!exists(file)) return "";
+  return String(read(file)).trim();
+}
+
+function resolveWin32Binary(fileName, pointerName, options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const exists = options.existsSync ?? existsSync;
+  const isolated = path.join(win32AppDir(home, { env }), fileName);
+  if (exists(isolated)) return isolated;
+  const pointed = readPointer(win32StorePointer(home, { env }, pointerName), options);
+  return pointed || isolated;
+}
+
 export function resolveCodexBinary(options = {}) {
   const env = options.env ?? process.env;
   if (env.CODEX_BINARY) return env.CODEX_BINARY;
-  return resolvePlatform({ ...options, env }) === "linux"
-    ? LINUX_CODEX_BINARY
-    : DARWIN_CODEX_BINARY;
+  const platform = resolvePlatform({ ...options, env });
+  if (platform === "linux") return LINUX_CODEX_BINARY;
+  if (platform === "win32") {
+    return resolveWin32Binary("codex.exe", "store-codex.txt", { ...options, env });
+  }
+  return DARWIN_CODEX_BINARY;
 }
 
 export function resolveDesktopApp(options = {}) {
   const env = options.env ?? process.env;
   if (env.CODEX_DESKTOP_APP) return env.CODEX_DESKTOP_APP;
-  return resolvePlatform({ ...options, env }) === "linux"
-    ? LINUX_CHATGPT_BIN
-    : DARWIN_CODEX_APP;
+  const platform = resolvePlatform({ ...options, env });
+  if (platform === "linux") return LINUX_CHATGPT_BIN;
+  if (platform === "win32") {
+    return resolveWin32Binary("ChatGPT.exe", "store-app.txt", { ...options, env });
+  }
+  return DARWIN_CODEX_APP;
 }
 
-export function desktopUserDataDir(home = homedir()) {
+export function resolveGrokBinary(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (env.GROK_BINARY) return env.GROK_BINARY;
+  const platform = resolvePlatform({ ...options, env });
+  const name = platform === "win32" ? "grok.exe" : "grok";
+  return path.join(home, ".grok", "bin", name);
+}
+
+export function desktopUserDataDir(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (resolvePlatform({ ...options, env }) === "win32") {
+    return path.join(localAppData(home, { env }), WIN32_BRIDGE_APP, "desktop");
+  }
   return path.join(home, ".local/share/codex-grok-bridge/desktop");
 }
 
@@ -60,22 +112,39 @@ export function isGrokDesktopProcess(line, userData, options = {}) {
   if (line.includes("Helper") || line.includes("crashpad")) return false;
   const app = resolveDesktopApp(options);
   if (line.includes(app)) return true;
-  return resolvePlatform(options) === "linux"
-    ? line.includes(LINUX_CHATGPT_BIN)
-    : /MacOS\/(ChatGPT|Codex)(\s|$)/.test(line);
+  const platform = resolvePlatform(options);
+  if (platform === "linux") return line.includes(LINUX_CHATGPT_BIN);
+  if (platform === "win32") {
+    return /ChatGPT\.exe|Codex\.exe/i.test(line);
+  }
+  return /MacOS\/(ChatGPT|Codex)(\s|$)/.test(line);
 }
 
 export function isForbiddenInstallDir(app) {
   const resolved = path.resolve(app);
+  const norm = resolved.replace(/\\/g, "/").toLowerCase();
+  const asPosix = String(app).replace(/\\/g, "/");
   const forbidden = [
     LINUX_STOCK_PREFIX,
     "/usr/bin/chatgpt",
     "/usr/share/applications/chatgpt.desktop",
     DARWIN_CODEX_APP,
   ];
-  return forbidden.some(
-    (prefix) => resolved === prefix || resolved.startsWith(`${prefix}/`),
-  );
+  if (
+    forbidden.some((prefix) => {
+      const p = prefix.toLowerCase();
+      return (
+        asPosix === prefix ||
+        asPosix.startsWith(`${prefix}/`) ||
+        norm === p ||
+        norm.endsWith(p) ||
+        norm.includes(`${p}/`)
+      );
+    })
+  ) {
+    return true;
+  }
+  return norm.includes("/windowsapps/") || norm.endsWith("/windowsapps");
 }
 
 export function linuxDesktopEntry({ exec, icon = "chatgpt" }) {

package/src/proxy.mjs

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { resolveGrokBinary } from "./paths.mjs";
 import { createSseRewriter } from "./tools.mjs";
 import { requestStream } from "./transport.mjs";
 import { BRIDGE_ERROR, classifyBridgeError } from "./errors.mjs";
@@ -15,7 +15,7 @@ export function detectGrokClientVersion(home = homedir()) {
   try {
     // Synchronous, and on the first request's critical path: a grok binary that
     // hangs would freeze the whole bridge event loop without a timeout.
-    const output = execFileSync(join(home, ".grok/bin/grok"), ["--version"], {
+    const output = execFileSync(resolveGrokBinary(home), ["--version"], {
       encoding: "utf8",
       timeout: 5000,
     });

package/src/router.mjs

@@ -1,25 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
+import { catalogModelEntries, isGrokModel, MODEL_ENTRY } from "./models.mjs";
 
-export const MODEL_ENTRY = {
-  id: "grok-4.6",
-  model: "grok-4.6",
-  displayName: "Grok 4.6 / xAI",
-  description: "Grok 4.6 · Codex tools",
-  hidden: false,
-  isDefault: false,
-  upgrade: null,
-  upgradeInfo: null,
-  availabilityNux: null,
-  supportedReasoningEfforts: ["low", "medium", "high", "xhigh"].map(
-    (reasoningEffort) => ({ reasoningEffort, description: reasoningEffort }),
-  ),
-  defaultReasoningEffort: "high",
-  inputModalities: ["text", "image"],
-  supportsPersonality: false,
-  multiAgentVersion: null,
-  additionalSpeedTiers: [],
-  serviceTiers: [],
-};
+export { MODEL_ENTRY };
 
 export class Router {
   constructor(catalogPath) {
@@ -45,7 +27,7 @@ export class Router {
     const fresh = this.unstarted.get(p.threadId);
     const snapshot = fresh ?? await rpc("thread/resume", { threadId: p.threadId, excludeTurns: true });
     const model = selected ?? snapshot.model;
-    const provider = model === "grok-4.6"
+    const provider = isGrokModel(model)
       ? "grok_build_cli"
       : model?.startsWith("gpt-") && snapshot.modelProvider === "grok_build_cli"
         ? "openai" : snapshot.modelProvider;
@@ -73,7 +55,7 @@ export class Router {
     const msg = structuredClone(message),
       p = msg.params ?? {};
     const model = p.collaborationMode?.settings?.model ?? p.model;
-    const grok = model === "grok-4.6";
+    const grok = isGrokModel(model);
     if (
       ["thread/start", "thread/resume", "thread/fork"].includes(
         msg.method,
@@ -95,12 +77,12 @@ export class Router {
     this.pending.delete(msg.id);
     if (request.method === "thread/start" && msg.result?.thread?.id)
       this.unstarted.set(msg.result.thread.id, structuredClone(msg.result));
-    if (
-      request.method === "model/list" &&
-      Array.isArray(msg.result?.data) &&
-      !msg.result.data.some((m) => m.id === "grok-4.6")
-    )
-      msg.result.data.push(MODEL_ENTRY);
+    if (request.method === "model/list" && Array.isArray(msg.result?.data)) {
+      for (const entry of catalogModelEntries()) {
+        if (!msg.result.data.some((m) => m.id === entry.id))
+          msg.result.data.push(entry);
+      }
+    }
     if (
       ["thread/start", "thread/resume", "thread/fork"].includes(
         request.method,

package/src/runtime.mjs

@@ -3,13 +3,14 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { once } from "node:events";
-import { createBridgeServer, MODEL_INFO } from "./bridge.mjs";
+import { createBridgeServer } from "./bridge.mjs";
+import { catalogModelInfos } from "./models.mjs";
 
 export async function startRuntime(options = {}) {
   const token = randomBytes(32).toString("hex");
   const dir = await mkdtemp(path.join(tmpdir(), "codex-grok-runtime-"));
   const catalogPath = path.join(dir, "models.json");
-  await writeFile(catalogPath, JSON.stringify({ models: [MODEL_INFO] }), {
+  await writeFile(catalogPath, JSON.stringify({ models: catalogModelInfos() }), {
     mode: 0o600,
   });
   const server = createBridgeServer({

package/src/tools.mjs

@@ -4,6 +4,7 @@ import {
   isImageGenerationItem,
   saveGeneratedImage,
 } from "./imagegen.mjs";
+import { resolveGrokModel } from "./models.mjs";
 
 const OBJECT_SCHEMA = { type: "object", properties: {} };
 
@@ -426,7 +427,7 @@ export function toProxyRequest(body) {
   const { tools, map } = flattenCodexTools(body.tools ?? []);
   const effort = EFFORT[body.reasoning?.effort] ?? "high";
   const request = {
-    model: "grok-4.6",
+    model: resolveGrokModel(body.model),
     input: toProxyInput(body.input, map),
     tools,
     reasoning: { effort },