codex-grok-bridge 1.0.5 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## Unreleased
+
+## 1.6.0 — 2026-09-27
+
+- Default catalog model is `grok-4.7` (`Grok 4.7 / xAI`). `grok-4.6` stays listed so existing threads still resolve.
+- `grok-*` still routes to `grok_build_cli`. No other model ids were added. `GROK_BRIDGE_MODELS` still appends extra `grok-*` ids.
+
+## 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/Open Codex with Grok.command

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Double-click to open the dedicated Codex window with Grok 4.6 available.
+# Double-click to open the dedicated Codex window with Grok 4.7 available.
 # Resolves everything from this file's own location, so the checkout can live
 # anywhere and be moved without editing this launcher.
 set -eu

package/README.md

@@ -1,26 +1,27 @@
 # codex-grok-bridge
 
-Run **Grok 4.6 as the model inside Codex**. Codex still owns tools, permissions,
-history and MCP. Inference uses the installed `grok` CLI login session — not an
+Run **Grok 4.7 as the model inside Codex**. Codex still owns tools, permissions,
+history and MCP. `grok-4.6` stays on the model list so existing threads still
+resolve. Inference uses the installed `grok` CLI login session — not an
 xAI API key.
 
 ```
-Codex UI/CLI → app-server → scripts/codex-wrapper.mjs (adds grok-4.6 to the model list)
+Codex UI/CLI → app-server → scripts/codex-wrapper.mjs (adds grok-4.7 and grok-4.6 to the model list)
              → localhost /v1/responses (the bridge)
              → cli-chat-proxy.grok.com
              → 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.
 
 
 ---
 ## What this is
 
-A local bridge that puts Grok 4.6 on Codex’s model list and sends Codex
+A local bridge that puts Grok 4.7 on Codex’s model list and sends Codex
 `/v1/responses` traffic to `cli-chat-proxy.grok.com`. Grok does the inference.
 Codex runs every tool call (shell, patch, MCP, …) and feeds the results back as
 the next request’s `input`. That is the same agent loop as the GPT path.
@@ -29,18 +30,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. The picker shows `grok-4.7` (Grok 4.7 / xAI) and keeps `grok-4.6`.
+Any other `grok-*` id uses the same route. `GROK_BRIDGE_MODELS` adds further
+`grok-*` ids. 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,8 +59,8 @@ re-verification.
 ### Terminal (npm)
 
 ```sh
-npm install -g codex-grok-bridge   # macOS or Linux, Node ≥ 22
-codex-grok                         # launches Codex with Grok 4.6 available
+npm install -g codex-grok-bridge   # macOS, Linux, or Windows; Node ≥ 22
+codex-grok                         # launches Codex with Grok 4.7 available
 codex-grok exec --skip-git-repo-check --sandbox workspace-write 'your task'
 ```
 
@@ -69,7 +72,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,11 +82,12 @@ 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
-open does not get this extension.
+In the new Codex window, **select Grok 4.7 / xAI before starting a new
+thread**. Existing GPT models stay on the list, and so does `grok-4.6`. A Codex
+window that was already open does not get this extension.
 
 The dedicated window stores UI data under
 `~/.local/share/codex-grok-bridge/desktop` and **shares** the normal Codex home
@@ -277,13 +281,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) beyond `grok-4.7` and `grok-4.6` |
 | `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 +303,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 +316,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
 
@@ -339,7 +348,7 @@ responses. Codex’s and Grok’s own retention policies still apply.
 
 ## 이게 뭔가
 
-Grok 4.6을 Codex 모델 목록에 넣고, Codex의 `/v1/responses`를
+Grok 4.7을 Codex 모델 목록에 넣고, Codex의 `/v1/responses`를
 `cli-chat-proxy.grok.com`으로 넘기는 로컬 브리지입니다. 추론은 Grok이 합니다.
 도구 호출(셸, 패치, MCP, …)은 Codex가 실행하고, 결과는 다음 요청의 `input`으로
 돌아갑니다. GPT 경로와 같은 에이전트 루프입니다.
@@ -348,18 +357,21 @@ 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 네이티브 검색 제품도 아닙니다. 피커에는
+`grok-4.7`(Grok 4.7 / xAI)이 기본으로 보이고 `grok-4.6`도 남습니다. 그 외
+`grok-*` id도 같은 경로로 붙고, `GROK_BRIDGE_MODELS`로 카탈로그에 더합니다.
+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,8 +386,8 @@ calling으로 옮기고, 상류 Responses 스트림을 전달한 뒤, Codex가
 ### 터미널 (npm)
 
 ```sh
-npm install -g codex-grok-bridge   # macOS or Linux, Node ≥ 22
-codex-grok                         # Grok 4.6이 있는 Codex를 띄움
+npm install -g codex-grok-bridge   # macOS, Linux, Windows; Node ≥ 22
+codex-grok                         # Grok 4.7이 있는 Codex를 띄움
 codex-grok exec --skip-git-repo-check --sandbox workspace-write '작업 내용'
 ```
 
@@ -387,7 +399,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,11 +409,12 @@ 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 창에는 이 확장이
-주입되지 않습니다.
+새로 열린 Codex 창에서 **새 작업을 시작하기 전에 Grok 4.7 / xAI를 선택**하세요.
+기존 GPT 모델과 `grok-4.6`도 목록에 남습니다. 이미 열려 있던 일반 Codex 창에는
+이 확장이 주입되지 않습니다.
 
 전용 창은 UI 데이터를 `~/.local/share/codex-grok-bridge/desktop`에 두고,
 계정·작업·설정은 기존 Codex 홈을 **공유**합니다. 작업 내용과 설정 변경은 다른
@@ -584,13 +597,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-4.7`과 `grok-4.6` 외에 카탈로그에 더할 `grok-*` id (쉼표/공백) |
 | `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 +619,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 +630,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,7 +1,7 @@
 {
   "name": "codex-grok-bridge",
-  "version": "1.0.5",
-  "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.",
+  "version": "1.6.0",
+  "description": "Run Grok 4.7 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",
   "author": "deximple",
@@ -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/codex-grok.mjs

@@ -2,6 +2,7 @@
 import { spawn } from "node:child_process";
 import { startRuntime } from "../src/runtime.mjs";
 import { resolveCodexBinary } from "../src/paths.mjs";
+import { DEFAULT_GROK_MODEL } from "../src/models.mjs";
 const runtime = await startRuntime();
 const userArgs = process.argv.slice(2);
 const overrides = [
@@ -11,7 +12,7 @@ const overrides = [
   "-c",
   `model_catalog_json=${JSON.stringify(runtime.catalogPath)}`,
   "-m",
-  "grok-4.6",
+  DEFAULT_GROK_MODEL,
 ];
 const args =
   userArgs[0] === "exec"

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

@@ -0,0 +1,93 @@
+# 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
+
+function Resolve-NodeExe {
+  $cmd = Get-Command node -ErrorAction SilentlyContinue
+  if ($cmd -and $cmd.Source) { return $cmd.Source }
+  if ($env:NODE) { return $env:NODE }
+  $candidates = @()
+  if ($env:ProgramFiles) {
+    $candidates += Join-Path $env:ProgramFiles "nodejs\node.exe"
+  }
+  $x86 = ${env:ProgramFiles(x86)}
+  if ($x86) {
+    $candidates += Join-Path $x86 "nodejs\node.exe"
+  }
+  if ($env:LOCALAPPDATA) {
+    $candidates += Join-Path $env:LOCALAPPDATA "Programs\nodejs\node.exe"
+    $candidates += Join-Path $env:LOCALAPPDATA "Programs\node\node.exe"
+  }
+  if ($env:USERPROFILE) {
+    $candidates += Join-Path $env:USERPROFILE "node\node.exe"
+    $candidates += Join-Path $env:USERPROFILE "nodejs\node.exe"
+  }
+  foreach ($candidate in $candidates) {
+    if ($candidate -and (Test-Path -LiteralPath $candidate)) { return $candidate }
+  }
+  Write-Error "node not found. Set NODE to the node.exe path, or install Node.js."
+}
+
+$Node = Resolve-NodeExe
+$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

@@ -7,8 +7,10 @@ import {
   desktopLaunchEnv,
   desktopUserDataDir,
   isGrokDesktopProcess,
+  parseWin32ProcessJson,
   resolveDesktopApp,
   resolvePlatform,
+  selectGrokDesktopPid,
 } from "../src/paths.mjs";
 
 const platform = resolvePlatform();
@@ -21,7 +23,44 @@ function log(message) {
   appendFileSync(logFile, `${new Date().toISOString()} ${message}\n`);
 }
 
+function grokPidWin32() {
+  try {
+    const injected = process.env.CODEX_GROK_CIM_JSON;
+    const rows =
+      injected != null
+        ? parseWin32ProcessJson(injected)
+        : parseWin32ProcessJson(queryWin32Processes());
+    return selectGrokDesktopPid(rows, userData, {
+      platform: "win32",
+      env: process.env,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function queryWin32Processes() {
+  const systemRoot = process.env.SystemRoot || "C:\\Windows";
+  const powershell = path.join(
+    systemRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe",
+  );
+  return execFileSync(
+    powershell,
+    [
+      "-NoProfile",
+      "-Command",
+      `Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $PID -and $_.CommandLine -like ${JSON.stringify(`*--user-data-dir=${userData}*`)} } | Select-Object ProcessId, CommandLine | ConvertTo-Json -Compress`,
+    ],
+    { encoding: "utf8", windowsHide: true, timeout: 15000 },
+  );
+}
+
 function grokPid() {
+  if (platform === "win32") return grokPidWin32();
   const out = execFileSync("/bin/ps", ["-axo", "pid=,command="], {
     encoding: "utf8",
   });
@@ -53,6 +92,34 @@ function notify(text) {
   } catch {}
 }
 
+function desktopCommand(app) {
+  if (/\.(mjs|cjs|js)$/i.test(app)) {
+    return { command: process.execPath, args: [app, ...desktopLaunchArgs(userData)] };
+  }
+  return { command: app, args: desktopLaunchArgs(userData) };
+}
+
+function startWin32(wrapper) {
+  const app = resolveDesktopApp();
+  const { command, args } = desktopCommand(app);
+  log(`start win32 app=${app} wrapper=${wrapper}`);
+  const child = spawn(command, args, {
+    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`;
@@ -115,18 +182,22 @@ try {
   const running = grokPid();
   if (running) {
     log(`activate pid=${running}`);
-    if (platform !== "darwin") {
-      process.exit(0);
-    }
-    try {
-      activate(running);
-      notify("Codex Grok 창을 앞으로 가져왔습니다.");
+    if (platform === "darwin") {
+      try {
+        activate(running);
+        notify("Codex Grok 창을 앞으로 가져왔습니다.");
+        process.exit(0);
+      } catch (error) {
+        log(`activate failed: ${error.message}`);
+      }
+    } else if (platform === "linux") {
+      // Fall through to startLinux so Electron can focus the existing window.
+    } else {
       process.exit(0);
-    } catch (error) {
-      log(`activate failed: ${error.message}`);
     }
   }
   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,122 @@
+export const DEFAULT_GROK_MODEL = "grok-4.7";
+export const GROK_PROVIDER = "grok_build_cli";
+const RETAINED_GROK_MODELS = ["grok-4.6"];
+
+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 = [];
+  const seen = new Set();
+  for (const id of [DEFAULT_GROK_MODEL, ...RETAINED_GROK_MODELS, ...extraGrokModels(env)]) {
+    if (!isGrokModel(id) || 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 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()) {
+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");
 }
 
@@ -41,14 +93,17 @@ export function linuxDesktopEntryPath(home = homedir(), xdgDataHome) {
   return path.join(dataHome, "applications", "codex-grok.desktop");
 }
 
-export function desktopLaunchEnv({ wrapper, userData, pathPrefix }) {
-  const env = {
+export function desktopLaunchEnv({ wrapper, userData, pathPrefix, env = process.env }) {
+  const next = {
     CODEX_CLI_PATH: wrapper,
     CODEX_APP_SERVER_FORCE_CLI: "1",
     CODEX_ELECTRON_USER_DATA_PATH: userData,
   };
-  if (pathPrefix) env.PATH = pathPrefix;
-  return env;
+  if (pathPrefix) {
+    const inherited = env.PATH ?? env.Path ?? "";
+    next.PATH = inherited ? `${pathPrefix}${path.delimiter}${inherited}` : pathPrefix;
+  }
+  return next;
 }
 
 export function desktopLaunchArgs(userData) {
@@ -60,22 +115,58 @@ 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 parseWin32ProcessJson(text) {
+  const raw = String(text ?? "").trim();
+  if (!raw) return [];
+  const data = JSON.parse(raw);
+  return Array.isArray(data) ? data : [data];
+}
+
+export function selectGrokDesktopPid(rows, userData, options = {}) {
+  const probePid = options.probePid;
+  for (const row of rows ?? []) {
+    const pid = Number(row?.ProcessId);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    if (probePid != null && pid === Number(probePid)) continue;
+    const line = String(row?.CommandLine ?? "");
+    if (isGrokDesktopProcess(line, userData, options)) return pid;
+  }
+  return null;
 }
 
 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 { DEFAULT_GROK_MODEL, resolveGrokModel } from "./models.mjs";
 
 const OBJECT_SCHEMA = { type: "object", properties: {} };
 
@@ -123,12 +124,11 @@ function mergeObjectFragments(fragments) {
   for (const fragment of fragments) {
     if (fragment.properties && typeof fragment.properties === "object")
       Object.assign(properties, fragment.properties);
-    if (Array.isArray(fragment.required)) {
-      required =
-        required === undefined
-          ? fragment.required.slice()
-          : required.filter((key) => fragment.required.includes(key));
-    }
+    const keys = Array.isArray(fragment.required) ? fragment.required : [];
+    required =
+      required === undefined
+        ? keys.slice()
+        : required.filter((key) => keys.includes(key));
   }
   return { properties, required };
 }
@@ -179,12 +179,14 @@ function usableParameters(parameters) {
       : {}),
     ...merged.properties,
   };
-  let required = merged.required;
-  if (Array.isArray(parameters.required)) {
-    required =
-      required === undefined
-        ? parameters.required.slice()
-        : required.filter((key) => parameters.required.includes(key));
+  const intersection = merged.required ?? [];
+  const root = Array.isArray(parameters.required) ? parameters.required : [];
+  const required = [];
+  const seen = new Set();
+  for (const key of [...root, ...intersection]) {
+    if (seen.has(key)) continue;
+    seen.add(key);
+    required.push(key);
   }
   const first = fragments[0];
   return emitObjectParameters(
@@ -406,11 +408,16 @@ function toProxyInput(input, map) {
 // no way to answer "is Grok actually attached?" and either hedges or goes
 // hunting through config files. Stated once, in the instructions, it costs a
 // few tokens and removes the whole class of question.
-export const TRANSPORT_PROVENANCE =
-  "Transport: this request is served by the local Codex-Grok bridge — model " +
-  "grok-4.6 via the grok_build_cli provider, with Codex owning tools, history " +
-  "and permissions. If asked whether Grok is attached to the Codex harness, " +
-  "this line is the authoritative answer and no tool call is needed to confirm it.";
+export function transportProvenance(model = DEFAULT_GROK_MODEL) {
+  return (
+    "Transport: this request is served by the local Codex-Grok bridge — model " +
+    `${model} via the grok_build_cli provider, with Codex owning tools, history ` +
+    "and permissions. If asked whether Grok is attached to the Codex harness, " +
+    "this line is the authoritative answer and no tool call is needed to confirm it."
+  );
+}
+
+export const TRANSPORT_PROVENANCE = transportProvenance();
 
 // Codex still injects its imagegen skill. That skill's fallback is OpenAI
 // (`image_gen` or a Python CLI). The model will read the skill and send the
@@ -426,7 +433,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 },
@@ -446,9 +453,10 @@ export function toProxyRequest(body) {
     request.tool_choice = proxyToolChoice(body.tool_choice, map);
     request.parallel_tool_calls = body.parallel_tool_calls !== false;
   }
+  const provenanceLine = transportProvenance(request.model);
   const provenance = imageGenOn
-    ? `${TRANSPORT_PROVENANCE}\n\n${IMAGE_GENERATION_PROVENANCE}`
-    : TRANSPORT_PROVENANCE;
+    ? `${provenanceLine}\n\n${IMAGE_GENERATION_PROVENANCE}`
+    : provenanceLine;
   request.instructions =
     typeof body.instructions === "string" && body.instructions
       ? `${body.instructions}\n\n${provenance}`