ocx-cursor 0.4.0 → 0.5.1

package/README.md

@@ -3,328 +3,114 @@
 [![npm version](https://img.shields.io/npm/v/ocx-cursor.svg)](https://www.npmjs.com/package/ocx-cursor)
 [![CI](https://github.com/hiddenest/opencodex-cursor-bridge/actions/workflows/ci.yml/badge.svg)](https://github.com/hiddenest/opencodex-cursor-bridge/actions/workflows/ci.yml)
 
-Use active [OpenCodex](https://github.com/lidge-jun/opencodex) models in Cursor through its custom OpenAI endpoint. The package runs a local gateway, registers the endpoint in Cursor, and keeps Cursor's custom model list in sync.
+Use your active [OpenCodex](https://github.com/lidge-jun/opencodex) models in Cursor through a local OpenAI-compatible gateway.
 
-## Requirements
+> [!WARNING]
+> This package edits private JavaScript files inside `Cursor.app`. The changes invalidate Cursor's vendor signature, so Cursor may report that the installation is corrupt. The installer saves original files under `~/.opencodex/cursor-bridge/cursor-app-backups`. Reinstall Cursor to restore a signed app.
 
-- macOS with Cursor installed at `/Applications/Cursor.app`
-- Node.js 22.5 or newer
-- A domain using Cloudflare DNS, or another HTTPS reverse proxy
+## Quick start
 
-Launch Cursor and sign in once before setup. Cursor creates the Safe Storage key that the installer uses to encrypt the gateway API key.
+You need macOS, Node.js 22.5 or newer, and Cursor at `/Applications/Cursor.app`.
 
-## Setup
-
-The commands below use `cursor-api.example.com`. Replace it with a hostname under your own Cloudflare-managed domain.
-
-### 1. Install OpenCodex
-
-[OpenCodex](https://github.com/lidge-jun/opencodex) requires Node.js 18 or newer and bundles its own Bun runtime. This bridge requires Node.js 22.5 or newer, so install Node.js 22 or later before continuing.
-
-Install OpenCodex without `sudo` from a user-owned Node.js installation:
+Install and configure OpenCodex:
 
 ```bash
 npm install --global @bitkyc08/opencodex
 ocx init
-```
-
-The bridge service looks for `ocx` at `~/.local/bin/ocx` and `/opt/homebrew/bin/ocx`. If `command -v ocx` prints another path, link it into `~/.local/bin`:
-
-```bash
-mkdir -p ~/.local/bin
-if [[ "$(command -v ocx)" != "$HOME/.local/bin/ocx" ]]; then
-  ln -sf "$(command -v ocx)" ~/.local/bin/ocx
-fi
-```
-
-`ocx init` opens the interactive provider setup. You can also open the dashboard and add or sign in to a provider there:
-
-```bash
-ocx gui
-```
-
-OAuth-backed providers can also be connected from the terminal:
-
-```bash
-ocx login <provider>
-```
-
-Install OpenCodex as a login service, then check it:
-
-```bash
 ocx service install
 ocx service status
 ```
 
-OpenCodex listens on `http://127.0.0.1:10100` by default. Confirm that its model endpoint responds:
-
-```bash
-curl http://127.0.0.1:10100/v1/models
-```
-
-If you configured OpenCodex with a service API token, include that token:
-
-```bash
-curl \
-  --header "Authorization: Bearer $(cat ~/.opencodex/service-api-token)" \
-  http://127.0.0.1:10100/v1/models
-```
-
-See the [OpenCodex documentation](https://lidge-jun.github.io/opencodex/) for provider-specific login and model configuration.
-
-### 2. Create a Cloudflare Tunnel
-
-Cursor requires an HTTPS custom OpenAI endpoint. A [Cloudflare Tunnel](https://developers.cloudflare.com/tunnel/) can publish the bridge on HTTPS without opening an inbound port on your router.
-
-Add your domain to Cloudflare and point its nameservers to Cloudflare. Then install `cloudflared` on the Mac that runs OpenCodex and Cursor:
-
-```bash
-brew install cloudflared
-cloudflared tunnel login
-```
-
-The login command opens Cloudflare in your browser and writes `~/.cloudflared/cert.pem`. Create a [locally-managed named tunnel](https://developers.cloudflare.com/tunnel/advanced/local-management/create-local-tunnel/):
+Check the configured models:
 
 ```bash
-cloudflared tunnel create ocx-cursor
-cloudflared tunnel list
-```
-
-Copy the tunnel UUID printed by the command. It also creates a credentials file named `<TUNNEL_UUID>.json` under `~/.cloudflared`.
-
-Create `~/.cloudflared/config.yml`. Replace the UUID, macOS username, and hostname in this example:
-
-```yaml
-# ~/.cloudflared/config.yml
-tunnel: YOUR_TUNNEL_UUID
-credentials-file: /Users/YOUR_MACOS_USERNAME/.cloudflared/YOUR_TUNNEL_UUID.json
-
-ingress:
-  - hostname: cursor-api.example.com
-    service: http://127.0.0.1:10101
-  - service: http_status:404
-```
-
-Create the DNS CNAME for the public hostname. The command adds the record to Cloudflare, so you do not need to create it separately in the dashboard:
-
-```bash
-cloudflared tunnel route dns ocx-cursor cursor-api.example.com
-```
-
-Validate the configuration and start the tunnel in the foreground:
-
-```bash
-cloudflared tunnel ingress validate
-cloudflared tunnel ingress rule https://cursor-api.example.com
-cloudflared tunnel run ocx-cursor
-```
-
-The public hostname returns `502 Bad Gateway` until the bridge is installed in the next step. Keep this terminal open while testing.
-
-For login-time startup on macOS, stop the foreground process and install the `cloudflared` launch agent:
-
-```bash
-cloudflared service install
+ocx models --json
 ```
 
-Use `sudo cloudflared service install` only if you want a system launch daemon that starts at boot. That mode reads its configuration from `/etc/cloudflared`, not your home directory. See Cloudflare's [macOS service guide](https://developers.cloudflare.com/tunnel/advanced/local-management/as-a-service/macos/) for the required file locations.
-
-This package does not create, modify, or remove the Cloudflare Tunnel.
-
-### 3. Install the Cursor bridge
-
-Quit Cursor completely, confirm that OpenCodex is running, then initialize the bridge:
+Launch Cursor and sign in once, then quit it. Run the bridge installer:
 
 ```bash
 npx ocx-cursor init
+~/.local/bin/ocx-cursor status
 ```
 
-Enter the Cloudflare Tunnel hostname when prompted. The `https://` prefix and `/v1` suffix are optional:
-
-```text
-Cloudflare Tunnel URL (for example, https://cursor-api.example.com): https://cursor-api.example.com
-```
-
-The installer starts the local bridge and tests two routes through Cloudflare before it changes Cursor:
-
-- `GET /healthz` confirms that the hostname reaches this bridge.
-- Authenticated `GET /v1/models` confirms that request headers reach the bridge and OpenCodex responds.
-
-If either check fails, `init` stops before writing Cursor's API settings. The local bridge stays running so you can fix the tunnel and rerun the command.
-
-For scripts and unattended setup, pass the URL directly:
-
-```bash
-npx ocx-cursor init \
-  --base-url https://cursor-api.example.com/v1
-```
-
-`init` performs these actions:
-
-1. Generates a gateway API key in `~/.opencodex/cursor-bridge/secret`.
-2. Installs the `com.opencodex.cursor-bridge` LaunchAgent.
-3. Tests the Cloudflare Tunnel and OpenCodex model endpoint.
-4. Stores the key in Cursor with macOS Safe Storage encryption.
-5. Registers the HTTPS URL as Cursor's OpenAI base URL.
-6. Adds active OpenCodex models to Cursor under `opencodex/*`.
+`init` registers `http://127.0.0.1:10101/v1` in Cursor. You do not need a domain or tunnel. Open Cursor after the status command reports `Service: running` and `Gateway: healthy`.
 
-The installer links `ocx-cursor` into `~/.local/bin`. Add that directory to `PATH` if your shell does not include it:
+Add the installed command to your shell path if needed:
 
 ```bash
 export PATH="$HOME/.local/bin:$PATH"
 ```
 
-Check the local gateway and public hostname before opening Cursor:
-
-```bash
-ocx-cursor status
-curl https://cursor-api.example.com/healthz
-```
-
-The status output should show `Service: running` and `Gateway: healthy`. The public health endpoint should return JSON with `"status":"ok"`.
-
-Open Cursor after both checks pass. Models with known reasoning controls show an effort value in the picker. Use `Shift+Command+/` to cycle it.
-
-### Fast mode
+## What init changes
 
-OpenAI models whose OpenCodex catalog advertises the `priority` service tier show a Fast toggle in Cursor. Fast is off by default. When enabled, the bridge sends `service_tier: "priority"` to OpenCodex, which increases generation speed and consumes more usage.
-
-Fast requires an OpenCodex version that preserves `service_tier` on its Chat Completions compatibility endpoint. Models without the `priority` tier, including Anthropic subscription models, do not receive the toggle.
+| Area | Change |
+| --- | --- |
+| Cursor settings | Stores the gateway key with macOS Safe Storage and sets the local base URL. |
+| Cursor model state | Adds active models under `opencodex/*` with names, effort choices, and Fast metadata. |
+| `Cursor.app` | Enables local-agent mode in eight bundles and patches two local-agent runtimes. |
+| Login service | Installs `com.opencodex.cursor-bridge`, refreshes models, and reapplies patches after Cursor updates. |
 
-## How requests are routed
+Requests stay on loopback until OpenCodex sends them to your configured provider:
 
 ```text
-Cursor
-  -> https://cursor-api.example.com/v1
-  -> Cloudflare Tunnel
-  -> OpenCodex Cursor Bridge on 127.0.0.1:10101
-  -> OpenCodex on 127.0.0.1:10100
-  -> configured provider
+Cursor -> 127.0.0.1:10101 -> OpenCodex on 127.0.0.1:10100 -> provider
 ```
 
-The gateway API key is generated during `init` and stored in Cursor with macOS Safe Storage encryption. The bridge requires this bearer token on every `/v1/*` request. Keep the bridge bound to `127.0.0.1`; `cloudflared` can reach it without exposing port `10101` to the local network.
-
-## Commands
-
-| Command | Purpose |
-| --- | --- |
-| `ocx-cursor init [--base-url URL]` | Install the service, prompt for and test the tunnel, configure Cursor, and sync models. Cursor must be closed. |
-| `ocx-cursor install` | Reinstall or restart the LaunchAgent without changing Cursor's API settings. |
-| `ocx-cursor update` | Download the latest `ocx-cursor` release from npm, reinstall the service, and sync models. |
-| `ocx-cursor sync` | Refresh the active model catalog. The service queues the update while Cursor runs. |
-| `ocx-cursor launch` | Experimentally launch Cursor with live effort and Fast metadata injection. Keep the command running. |
-| `ocx-cursor status` | Show service health, model count, and pending sync state. |
-| `ocx-cursor uninstall` | Remove the LaunchAgent, command link, and bridge home directory. |
-
-`uninstall` leaves Cursor's custom endpoint and model records in its state database.
-
-`update` preserves the existing gateway API key and Cursor endpoint. It updates only this companion package; update OpenCodex separately with your package manager.
+The gateway requires its generated bearer token on every `/v1/*` request. It binds to `127.0.0.1` unless you change `OCX_CURSOR_HOST`.
 
-## Model mapping
+## Model behavior
 
-The bridge maps source model IDs to Cursor aliases:
+The bridge reads OpenCodex's active `/v1/models` response and creates stable Cursor aliases:
 
 ```text
-anthropic/claude-sonnet-5  -> opencodex/claude-sonnet-5
-gpt-5.6-sol                -> opencodex/gpt-5.6-sol
+anthropic/claude-sonnet-5 -> opencodex/claude-sonnet-5
+gpt-5.6-sol               -> opencodex/gpt-5.6-sol
 ```
 
-The catalog includes models returned by OpenCodex's active `/v1/models` endpoint. It excludes the OpenCodex `cursor/*` provider to avoid duplicating Cursor's own models.
+Cursor shows readable names such as `GPT 5.6 Sol`. Reasoning models receive an effort selector. Models with OpenCodex's `priority` service tier receive a Fast toggle.
 
-Cursor removes custom effort metadata from its database during startup. The LaunchAgent writes that metadata back after Cursor exits, once all Cursor Helper processes have stopped.
+Cursor can send `strict: true` with function schemas that fail strict validation. The gateway changes the flag to `false` before forwarding those requests. It leaves tool names, descriptions, and arguments intact.
 
-### Experimental live model metadata
+## Commands and configuration
 
-`ocx-cursor launch` starts Cursor with a random loopback-only debugging port and keeps `opencodex/*` effort and Fast metadata in the live model catalog:
-
-```bash
-ocx-cursor launch
-```
-
-Keep the command running for the lifetime of Cursor. This does not modify `Cursor.app`, but it depends on Cursor's private workbench code and currently supports Cursor 3.14.7. The command stops with a compatibility error when it cannot find the expected catalog hook.
-
-## Configuration
-
-| Variable | Default | Purpose |
-| --- | --- | --- |
-| `OCX_CURSOR_BASE_URL` | Stored Cursor URL | Prompt default, or endpoint for non-interactive `init`, when `--base-url` is absent. |
-| `OCX_CURSOR_HOME` | `~/.opencodex/cursor-bridge` | Service state, API key, catalog, and logs. |
-| `OCX_CURSOR_HOST` | `127.0.0.1` | Local gateway bind address. |
-| `OCX_CURSOR_PORT` | `10101` | Local gateway port. |
-| `OCX_BIN` | `~/.local/bin/ocx` | OpenCodex CLI path. |
+| Command | Purpose |
+| --- | --- |
+| `ocx-cursor init` | Install the service, configure Cursor, patch the app, and sync models. Cursor must be closed. |
+| `ocx-cursor install` | Reinstall the service and check app patches. Running Cursor defers app changes until exit. |
+| `ocx-cursor update` | Install the newest npm release and run `install`. |
+| `ocx-cursor sync` | Refresh the active model list. |
+| `ocx-cursor status` | Show service health and pending model sync. |
+| `ocx-cursor uninstall` | Remove the service, command link, and bridge state. |
 
-The gateway accepts these routes:
+`uninstall` does not restore Cursor settings or patched app files. Reinstall Cursor if you want a clean vendor build.
 
-- `GET /v1/models`
-- `POST /v1/chat/completions`
-- `POST /v1/responses` and `/v1/responses/compact`
-- `POST /v1/messages`
+| Variable | Default |
+| --- | --- |
+| `OCX_CURSOR_BASE_URL` | `http://127.0.0.1:10101/v1` |
+| `OCX_CURSOR_HOME` | `~/.opencodex/cursor-bridge` |
+| `OCX_CURSOR_HOST` | `127.0.0.1` |
+| `OCX_CURSOR_PORT` | `10101` |
+| `OCX_BIN` | `~/.local/bin/ocx` |
 
-The gateway requires its generated bearer token on each `/v1/*` request. It binds to loopback unless you change `OCX_CURSOR_HOST`.
+The bridge reads an OpenCodex service token from `~/.opencodex/service-api-token` when that file exists.
 
 ## Troubleshooting
 
-### The public hostname returns 502
-
-The tunnel is running, but it cannot reach the local bridge. Check the bridge and its logs:
+| Symptom | Fix |
+| --- | --- |
+| Cursor returns 401 | Quit Cursor and rerun `npx ocx-cursor init`. |
+| Models or effort choices are missing | Quit Cursor, run `ocx-cursor sync`, then check `ocx-cursor status`. |
+| A Cursor update removed the patches | Quit Cursor and run `ocx-cursor install`. |
+| The gateway is unavailable | Run `ocx-cursor status` and inspect the logs below. |
+| The bridge cannot find `ocx` | Run `ln -sf "$(command -v ocx)" ~/.local/bin/ocx`. |
 
 ```bash
-ocx-cursor status
-tail -n 100 ~/.opencodex/cursor-bridge/service.error.log
 tail -n 100 ~/.opencodex/cursor-bridge/service.log
+tail -n 100 ~/.opencodex/cursor-bridge/service.error.log
 ```
 
-Confirm that the tunnel ingress points to `http://127.0.0.1:10101`, then restart the bridge if needed:
-
-```bash
-ocx-cursor install
-```
-
-### Cloudflare returns error 1016
-
-The DNS record exists, but no tunnel connector is online. Check the named tunnel and start it:
-
-```bash
-cloudflared tunnel info ocx-cursor
-cloudflared tunnel run ocx-cursor
-```
-
-If you installed the login service, inspect it with:
-
-```bash
-launchctl print "gui/$(id -u)/com.cloudflare.cloudflared"
-```
-
-### Cursor returns 401
-
-Run `init` again while Cursor is closed. It preserves the bridge key, retests the tunnel, and writes the matching encrypted value back to Cursor:
-
-```bash
-npx ocx-cursor init
-```
-
-### Models or effort options are missing
-
-Cursor must be closed before its local model database can be changed. Quit Cursor and run:
-
-```bash
-ocx-cursor sync
-ocx-cursor status
-```
-
-If the status shows a pending sync, wait until every Cursor Helper process has exited. The service applies the queued catalog automatically.
-
-### OpenCodex models cannot be loaded
-
-Check OpenCodex first:
-
-```bash
-ocx status
-ocx models --json
-curl http://127.0.0.1:10100/v1/models
-```
-
-If `ocx models --json` works in your shell but fails in the bridge, check that `ocx` is available at `~/.local/bin/ocx` or `/opt/homebrew/bin/ocx`. The macOS LaunchAgent does not load your interactive shell profile.
+The patcher stops when a Cursor update no longer matches its known code structure. It reports the file and mismatch in `service.error.log` without replacing that file.
 
 ## Development
 
@@ -334,14 +120,4 @@ npm run check
 npm pack --dry-run
 ```
 
-The code uses `node:sqlite`, so development requires Node.js 22.5 or newer.
-
-## Compatibility
-
-The package writes Cursor's local state database and uses Cursor's Safe Storage format. Cursor does not document either interface. A Cursor update can change them.
-
-The current release supports macOS. It does not configure Windows Credential Manager, Linux keyrings, or system services outside launchd.
-
-## License
-
-MIT
+The project uses the MIT license.

package/bin/ocx-cursor.mjs

@@ -2,21 +2,20 @@
 
 import { readFile } from "node:fs/promises";
 import process from "node:process";
-import { createInterface } from "node:readline/promises";
-import { configureCursorOpenAI, storedCursorOpenAIBaseUrl } from "../src/cursor-config.mjs";
+import { configureCursorOpenAI } from "../src/cursor-config.mjs";
 import { cursorIsRunning } from "../src/cursor-state.mjs";
 import { installService, prepareInstallSecret, serviceStatus, uninstallService, updateService } from "../src/install.mjs";
-import { cursorOpenAIBaseUrl, pendingFile } from "../src/paths.mjs";
+import { cursorLocalBaseUrl, cursorOpenAIBaseUrl, pendingFile } from "../src/paths.mjs";
 import { runService } from "../src/service.mjs";
-import { normalizeBaseUrl, testTunnel } from "../src/setup.mjs";
+import { normalizeBaseUrl, testEndpoint } from "../src/setup.mjs";
 import { loadCatalogSnapshot, syncNow } from "../src/sync.mjs";
 import { findAvailableDebugPort, launchCursorForInjection, runRuntimeInjector } from "../src/runtime-injector.mjs";
 
 const usage = `OpenCodex Cursor Bridge
 
 Usage:
-  ocx-cursor init [--base-url <https-url>]
-                        Install the service, test the tunnel, configure Cursor,
+  ocx-cursor init [--base-url <url>]
+                        Install the service, test the endpoint, configure Cursor,
                         and sync models
   ocx-cursor install    Install and start the macOS companion service
   ocx-cursor update     Install the latest companion release and restart it
@@ -37,19 +36,7 @@ function argumentValue(name) {
 
 async function requestedBaseUrl() {
   const supplied = argumentValue("--base-url");
-  const fallback = cursorOpenAIBaseUrl || storedCursorOpenAIBaseUrl();
-  if (supplied) return normalizeBaseUrl(supplied);
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return normalizeBaseUrl(fallback);
-
-  const prompt = fallback
-    ? `Cloudflare Tunnel URL [${fallback}]: `
-    : "Cloudflare Tunnel URL (for example, https://cursor-api.example.com): ";
-  const readline = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return normalizeBaseUrl((await readline.question(prompt)).trim() || fallback);
-  } finally {
-    readline.close();
-  }
+  return normalizeBaseUrl(supplied || cursorOpenAIBaseUrl || cursorLocalBaseUrl);
 }
 
 async function pendingCount() {
@@ -70,6 +57,15 @@ function printSync(result) {
   }
 }
 
+function printCursorPatches(result) {
+  if (result.cursorPatches === null) {
+    process.stdout.write("Cursor app patches will be applied after Cursor quits.\n");
+    return;
+  }
+  const changed = result.cursorPatches.filter(({ status }) => status === "patched").length;
+  process.stdout.write(`Verified ${result.cursorPatches.length} Cursor app patches (${changed} changed).\n`);
+}
+
 async function main() {
   const command = process.argv[2] || "help";
   if (["help", "--help", "-h"].includes(command)) {
@@ -85,6 +81,7 @@ async function main() {
   if (command === "install") {
     const installed = await installService();
     process.stdout.write(`Installed ${installed.launchAgentFile} (API key ${installed.secretStatus}).\nCLI: ${installed.cliLinkFile}\n`);
+    printCursorPatches(installed);
     printSync(await syncNow());
     process.stdout.write("Endpoint: http://127.0.0.1:10101/v1\n");
     return;
@@ -97,14 +94,15 @@ async function main() {
     const prepared = await prepareInstallSecret();
     const installed = await installService();
     process.stdout.write(`Installed ${installed.launchAgentFile} (API key ${prepared.secretStatus}).\nCLI: ${installed.cliLinkFile}\n`);
-    process.stdout.write(`Testing Cloudflare Tunnel: ${new URL(baseUrl).origin}\n`);
-    let tunnel;
+    printCursorPatches(installed);
+    process.stdout.write(`Testing endpoint: ${new URL(baseUrl).origin}\n`);
+    let endpoint;
     try {
-      tunnel = await testTunnel(baseUrl, prepared.secret);
+      endpoint = await testEndpoint(baseUrl, prepared.secret);
     } catch (error) {
-      throw new Error(`${error.message}\nThe bridge service is running locally. Fix the tunnel and rerun ocx-cursor init.`);
+      throw new Error(`${error.message}\nThe bridge service is running locally. Fix the endpoint and rerun ocx-cursor init.`);
     }
-    process.stdout.write(`Tunnel is ready (${tunnel.modelCount} models reachable).\n`);
+    process.stdout.write(`Endpoint is ready (${endpoint.modelCount} models reachable).\n`);
     const configured = await configureCursorOpenAI({
       secret: prepared.secret,
       baseUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocx-cursor",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "OpenCodex companion service for Cursor custom models",
   "keywords": [
     "opencodex",

package/src/catalog.mjs

@@ -80,7 +80,7 @@ export function normalizeActiveCatalog(configured, active, fastModelIds = new Se
   const models = new Map();
 
   for (const model of active) {
-    if (typeof model?.id !== "string" || model.owned_by === "opencodex" || model.id.startsWith("cursor/")) continue;
+    if (typeof model?.id !== "string" || model.owned_by === "opencodex") continue;
     const configuredModel = configuredById.get(model.id);
     const provider = model.id.includes("/") ? model.id.split("/", 1)[0] : String(model.owned_by || "openai").toLowerCase();
     const inputModalities = Array.isArray(configuredModel?.inputModalities)

package/src/cursor-patch.mjs

@@ -0,0 +1,323 @@
+import { createHash } from "node:crypto";
+import { chmod, copyFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import {
+  cursorBundleFiles,
+  cursorGlassWorkbenchFile,
+  cursorLocalRuntimeFiles,
+  cursorPatchBackupDirectory,
+  cursorWorkbenchFile,
+} from "./paths.mjs";
+
+export const cursorPatchMarker = "/*ocx-cursor-model-metadata-v4*/";
+export const legacyCursorPatchMarker = "/*ocx-cursor-model-metadata*/";
+export const cursorLocalModeDisabled = "localMode:!1";
+export const cursorLocalModeEnabled = "localMode:!0";
+export const cursorLocalRuntimePatchMarker = "/*ocx-cursor-local-model-display*/";
+export const cursorLocalRuntimeCapabilitiesPatchMarker = "/*ocx-cursor-local-model-capabilities-v3*/";
+export const legacyCursorLocalRuntimeCapabilitiesPatchMarker = "/*ocx-cursor-local-model-capabilities-v2*/";
+
+export function isCursorModelMetadataBundle(file) {
+  return file === cursorWorkbenchFile || file === cursorGlassWorkbenchFile;
+}
+
+const catalogNormalization = /(?<normalization>\b(?<catalog>[A-Za-z_$][\w$]*)=\k<catalog>\.map\((?<item>[A-Za-z_$][\w$]*)=>(?<plain>[A-Za-z_$][\w$]*)\(\k<item>\)\)),(?=(?<batch>[A-Za-z_$][\w$]*)\(\(\)=>\{this\._reactiveStorageService\.setApplicationUserPersistentStorage\("availableDefaultModels2",\k<catalog>\))/g;
+const previousCatalogInjection = /\/\*ocx-cursor-model-metadata(?:-v[23])?\*\/(?<catalog>[A-Za-z_$][\w$]*)=\k<catalog>\.map\(ocxCursorModel=>\{.*?\}\),(?=(?<batch>[A-Za-z_$][\w$]*)\(\(\)=>\{this\._reactiveStorageService\.setApplicationUserPersistentStorage\("availableDefaultModels2",\k<catalog>\))/g;
+const localModelConstructor = /function (?<functionName>[A-Za-z_$][\w$]*)\(e,t\)\{return new (?<modelType>[A-Za-z_$][\w$]*\.[A-Za-z_$][\w$]*)\(\{modelId:e,displayModelId:e,displayName:null!=t\?t:e,displayNameShort:null!=t\?t:e,aliases:\[\]\}\)\}/g;
+const localRuntimeVisionCapability = /"boolean"==typeof (?<object>[A-Za-z_$][\w$]*)\.supports_vision\?\{supports_vision:\k<object>\.supports_vision\}:\{\}\)/g;
+const localRuntimePickerInput = /toPickerInput\((?<model>[A-Za-z_$][\w$]*)\)\{var [A-Za-z_$][\w$]*;const [A-Za-z_$][\w$]*=this\.modelMetadataById\.get\(\k<model>\.modelId\),(?<capabilities>[A-Za-z_$][\w$]*)=.*?;return\{.*?supportsReasoning:[^,]+,supportsVision:/g;
+const localRuntimeProviderPickerInput = /supportsReasoning:(?<reasoning>!0===\(null===\((?<capability>[A-Za-z_$][\w$]*)=(?<model>[A-Za-z_$][\w$]*)\.capabilities\)\|\|void 0===\k<capability>\?void 0:\k<capability>\.supports_reasoning\)),supportsVision:/g;
+const localRuntimeRequestParameters = /function\((?<payload>[A-Za-z_$][\w$]*),(?<model>[A-Za-z_$][\w$]*),(?<parameters>[A-Za-z_$][\w$]*),(?<apiType>[A-Za-z_$][\w$]*),(?<route>[A-Za-z_$][\w$]*),(?<extended>[A-Za-z_$][\w$]*)=!1\)\{(?=const [A-Za-z_$][\w$]*=function\([A-Za-z_$][\w$]*\)\{var [A-Za-z_$][\w$]*;const [A-Za-z_$][\w$]*=.*?\["reasoning","effort","thought_level"\]\.includes)/g;
+const localRuntimeBuilderExport = /buildBottlerocketPickerModels:\(\)=>(?<builder>[A-Za-z_$][\w$]*)/g;
+const transientPatchErrorCodes = new Set(["EACCES", "EBUSY", "EPERM"]);
+
+function replaceSingleMatch(source, pattern, replacement, label) {
+  const matches = [...source.matchAll(pattern)];
+  if (matches.length !== 1) throw new Error(`Expected one Cursor ${label}, found ${matches.length}`);
+  const match = matches[0];
+  const value = typeof replacement === "function" ? replacement(match) : replacement;
+  return `${source.slice(0, match.index)}${value}${source.slice(match.index + match[0].length)}`;
+}
+
+function metadataInjection(catalog) {
+  return `${cursorPatchMarker}${catalog}=${catalog}.map(ocxCursorModel=>{if(!ocxCursorModel.name.startsWith("opencodex/"))return ocxCursorModel;const ocxCursorStored=(this._reactiveStorageService.applicationUserPersistentStorage.availableDefaultModels2??[]).find(ocxCursorCandidate=>ocxCursorCandidate?.name===ocxCursorModel.name);const ocxCursorDisplayWords={claude:"Claude",codex:"Codex",composer:"Composer",deepseek:"DeepSeek",fable:"Fable",fast:"Fast",flash:"Flash",gpt:"GPT",grok:"Grok",hy3:"HY3",kimi:"Kimi",luna:"Luna",max:"Max",mimo:"MiMo",mini:"Mini",opus:"Opus",pro:"Pro",qwen:"Qwen",sol:"Sol",sonnet:"Sonnet",spark:"Spark",terra:"Terra"};const ocxCursorDisplayName=ocxCursorModel.name.split("/").at(-1).split("-").map(ocxCursorWord=>{if(ocxCursorDisplayWords[ocxCursorWord])return ocxCursorDisplayWords[ocxCursorWord];const ocxCursorAttached=/^(qwen|kimi|gpt|claude|grok)(\\d+(?:\\.\\d+)*)$/.exec(ocxCursorWord);if(ocxCursorAttached)return ocxCursorDisplayWords[ocxCursorAttached[1]]+" "+ocxCursorAttached[2];if(/^v\\d/i.test(ocxCursorWord))return"V"+ocxCursorWord.slice(1);if(/^k\\d/i.test(ocxCursorWord))return"K"+ocxCursorWord.slice(1);if(/^\\d/.test(ocxCursorWord))return ocxCursorWord;return ocxCursorWord.slice(0,1).toUpperCase()+ocxCursorWord.slice(1)}).join(" ");const ocxCursorPrettyLabel=ocxCursorValue=>typeof ocxCursorValue==="string"?ocxCursorValue.split(ocxCursorModel.name).join(ocxCursorDisplayName):ocxCursorValue;const ocxCursorDefinitions=Array.isArray(ocxCursorModel.parameterDefinitions)&&ocxCursorModel.parameterDefinitions.length>0?ocxCursorModel.parameterDefinitions:ocxCursorStored?.parameterDefinitions??[];const ocxCursorVariantSource=Array.isArray(ocxCursorModel.variants)&&ocxCursorModel.variants.length>0?ocxCursorModel.variants:ocxCursorStored?.variants??[];const ocxCursorVariants=ocxCursorVariantSource.map(ocxCursorVariant=>({...ocxCursorVariant,displayName:ocxCursorPrettyLabel(ocxCursorVariant.displayName),displayNameOutsidePicker:ocxCursorPrettyLabel(ocxCursorVariant.displayNameOutsidePicker)}));const ocxCursorLegacySlugs=Array.isArray(ocxCursorModel.legacySlugs)&&ocxCursorModel.legacySlugs.length>0?ocxCursorModel.legacySlugs:ocxCursorStored?.legacySlugs??[];return{...ocxCursorModel,clientDisplayName:ocxCursorDisplayName,inputboxShortModelName:ocxCursorDisplayName,parameterDefinitions:ocxCursorDefinitions,variants:ocxCursorVariants,legacySlugs:ocxCursorLegacySlugs,supportsThinking:void 0!==ocxCursorModel.supportsThinking?ocxCursorModel.supportsThinking:ocxCursorStored?.supportsThinking}}),`;
+}
+
+export function patchCursorWorkbenchSource(source) {
+  if (source.includes(cursorPatchMarker)) return { status: "already-patched", source };
+  if (source.includes(legacyCursorPatchMarker) || source.includes("/*ocx-cursor-model-metadata-v2*/") || source.includes("/*ocx-cursor-model-metadata-v3*/")) {
+    const matches = [...source.matchAll(previousCatalogInjection)];
+    if (matches.length !== 1) {
+      throw new Error(`Expected one legacy Cursor model metadata hook, found ${matches.length}`);
+    }
+    const match = matches[0];
+    const replacement = metadataInjection(match.groups.catalog);
+    return {
+      status: "patched",
+      source: `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`,
+    };
+  }
+  const matches = [...source.matchAll(catalogNormalization)];
+  if (matches.length !== 1) {
+    throw new Error(`Expected one Cursor model catalog storage hook, found ${matches.length}`);
+  }
+  const match = matches[0];
+  const { normalization, catalog } = match.groups;
+  const injection = `${normalization},${metadataInjection(catalog)}`;
+  const patched = `${source.slice(0, match.index)}${injection}${source.slice(match.index + match[0].length)}`;
+  return { status: "patched", source: patched };
+}
+
+export function patchCursorLocalModeSource(source) {
+  const disabledCount = source.split(cursorLocalModeDisabled).length - 1;
+  if (disabledCount > 1) {
+    throw new Error(`Expected at most one disabled Cursor localMode flag, found ${disabledCount}`);
+  }
+  if (disabledCount === 1) {
+    return {
+      status: "patched",
+      source: source.replace(cursorLocalModeDisabled, cursorLocalModeEnabled),
+    };
+  }
+  if (source.includes(cursorLocalModeEnabled)) return { status: "already-patched", source };
+  throw new Error("Cursor localMode build flag was not found");
+}
+
+export function patchCursorBundleSource(source, options = {}) {
+  const localMode = patchCursorLocalModeSource(source);
+  const metadata = options.preserveCatalogMetadata
+    ? patchCursorWorkbenchSource(localMode.source)
+    : { status: "already-patched", source: localMode.source };
+  return {
+    status: localMode.status === "patched" || metadata.status === "patched"
+      ? "patched"
+      : "already-patched",
+    source: metadata.source,
+  };
+}
+
+function patchCursorLocalRuntimeDisplayName(source) {
+  if (source.includes(cursorLocalRuntimePatchMarker)) return source;
+  const matches = [...source.matchAll(localModelConstructor)];
+  if (matches.length !== 1) {
+    throw new Error(`Expected one Cursor local model constructor, found ${matches.length}`);
+  }
+  const match = matches[0];
+  const { functionName, modelType } = match.groups;
+  const replacement = `function ${functionName}(e,t){${cursorLocalRuntimePatchMarker}const ocxCursorDisplayWords={claude:"Claude",codex:"Codex",composer:"Composer",deepseek:"DeepSeek",fable:"Fable",fast:"Fast",flash:"Flash",gpt:"GPT",grok:"Grok",hy3:"HY3",kimi:"Kimi",luna:"Luna",max:"Max",mimo:"MiMo",mini:"Mini",opus:"Opus",pro:"Pro",qwen:"Qwen",sol:"Sol",sonnet:"Sonnet",spark:"Spark",terra:"Terra"};const ocxCursorDisplayName=null!=t?t:e.startsWith("opencodex/")?e.split("/").at(-1).split("-").map(ocxCursorWord=>{if(ocxCursorDisplayWords[ocxCursorWord])return ocxCursorDisplayWords[ocxCursorWord];const ocxCursorAttached=/^(qwen|kimi|gpt|claude|grok)(\\d+(?:\\.\\d+)*)$/.exec(ocxCursorWord);if(ocxCursorAttached)return ocxCursorDisplayWords[ocxCursorAttached[1]]+" "+ocxCursorAttached[2];if(/^v\\d/i.test(ocxCursorWord))return"V"+ocxCursorWord.slice(1);if(/^k\\d/i.test(ocxCursorWord))return"K"+ocxCursorWord.slice(1);if(/^\\d/.test(ocxCursorWord))return ocxCursorWord;return ocxCursorWord.slice(0,1).toUpperCase()+ocxCursorWord.slice(1)}).join(" "):e;return new ${modelType}({modelId:e,displayModelId:e,displayName:ocxCursorDisplayName,displayNameShort:ocxCursorDisplayName,aliases:[]})}`;
+  return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
+}
+
+function patchCursorLocalRuntimeCapabilities(source) {
+  source = replaceSingleMatch(source, localRuntimeVisionCapability, (match) => {
+    const object = match.groups.object;
+    return `${match[0].slice(0, -1)},"boolean"==typeof ${object}.supports_fast?{supports_fast:${object}.supports_fast}:{})`;
+  }, "local model capability parser");
+
+  source = replaceSingleMatch(source, localRuntimePickerInput, (match) => {
+    const capabilities = match.groups.capabilities;
+    return match[0].replace(
+      ",supportsVision:",
+      `,reasoningEfforts:Array.isArray(${capabilities}?.reasoning_effort)?${capabilities}.reasoning_effort:void 0,supportsFast:!0===${capabilities}?.supports_fast,supportsVision:`,
+    );
+  }, "local picker input mapper");
+
+  source = patchCursorLocalRuntimeProviderCapabilities(source);
+
+  source = replaceSingleMatch(source, localRuntimeRequestParameters, (match) => {
+    const { payload, parameters } = match.groups;
+    return `${match[0]}const ocxCursorFast=${parameters}?.find(ocxCursorParameter=>ocxCursorParameter.id==="fast")?.value;if(ocxCursorFast==="true")${payload}.service_tier="priority";else if(ocxCursorFast==="false")delete ${payload}.service_tier;`;
+  }, "local request parameter mapper");
+
+  const exportMatches = [...source.matchAll(localRuntimeBuilderExport)];
+  if (exportMatches.length !== 1) {
+    throw new Error(`Expected one Cursor local picker builder export, found ${exportMatches.length}`);
+  }
+  const builderName = exportMatches[0].groups.builder;
+  const builderStart = source.indexOf(`function ${builderName}(`, exportMatches[0].index);
+  if (builderStart === -1) throw new Error("Cursor local picker builder was not found");
+  const builderHead = source.slice(builderStart, builderStart + 1_000);
+  const modelBuilderName = /\.push\((?<name>[A-Za-z_$][\w$]*)\(/.exec(builderHead)?.groups.name;
+  if (!modelBuilderName) throw new Error("Cursor local picker model builder was not found");
+
+  const modelBuilderStart = source.indexOf(`function ${modelBuilderName}(`, builderStart);
+  const modelBuilderSource = source.slice(modelBuilderStart, modelBuilderStart + 6_000);
+  const signature = new RegExp(`function ${modelBuilderName}\\((?<model>[A-Za-z_$][\\w$]*),(?<tier>[A-Za-z_$][\\w$]*)\\)\\{var [^;]+;const (?<effort>[A-Za-z_$][\\w$]*)=function\\((?<inner>[A-Za-z_$][\\w$]*)\\)\\{`).exec(modelBuilderSource);
+  if (!signature) throw new Error("Cursor local picker model effort builder was not found");
+  const { model, effort } = signature.groups;
+  const effortPrefix = `const ${effort}=function(`;
+  const effortIndex = modelBuilderSource.indexOf(effortPrefix);
+  const effortReplacement = `const ${effort}=Array.isArray(${model}.reasoningEfforts)&&${model}.reasoningEfforts.length>0?{param:"reasoning_effort",values:${model}.reasoningEfforts,defaultValue:${model}.reasoningEfforts.includes("medium")?"medium":${model}.reasoningEfforts.includes("high")?"high":${model}.reasoningEfforts[0]}:function(`;
+  let patchedBuilder = `${modelBuilderSource.slice(0, effortIndex)}${effortReplacement}${modelBuilderSource.slice(effortIndex + effortPrefix.length)}`;
+
+  const definitions = new RegExp(`(?<name>[A-Za-z_$][\\w$]*)=\\[\\.\\.\\.void 0!==${effort}\\?`).exec(patchedBuilder)?.groups.name;
+  const parameterClass = /new (?<name>[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?)\(\{id:"reasoning"/.exec(patchedBuilder)?.groups.name;
+  if (!definitions || !parameterClass) throw new Error("Cursor local picker parameter definition builder was not found");
+  const definitionsEnd = patchedBuilder.indexOf("];var ", patchedBuilder.indexOf(`${definitions}=[`));
+  if (definitionsEnd === -1) throw new Error("Cursor local picker parameter definitions were not terminated");
+  const fastDefinition = `];${model}.supportsFast&&${definitions}.push(new ${parameterClass}({id:"fast",name:"Fast",markdownTooltip:"Use priority processing with increased usage.",parameterType:{booleanParameter:{values:[{value:"false"},{value:"true",displayName:"Fast",increasesModelCost:!0}]}},isCycleableByHotkey:!1}))`;
+  patchedBuilder = `${patchedBuilder.slice(0, definitionsEnd)}${fastDefinition}${patchedBuilder.slice(definitionsEnd + 1)}`;
+
+  const variantMatch = new RegExp(`variants:(?<call>[A-Za-z_$][\\w$]*\\(${effort},(?<context>[A-Za-z_$][\\w$]*),(?<display>[A-Za-z_$][\\w$]*),(?<tier>[A-Za-z_$][\\w$]*)\\))`).exec(patchedBuilder);
+  if (!variantMatch) throw new Error("Cursor local picker variant builder was not found");
+  const variantReplacement = `variants:ocxCursorFastVariants(${variantMatch.groups.call},${model}.supportsFast,${variantMatch.groups.display})`;
+  patchedBuilder = `${patchedBuilder.slice(0, variantMatch.index)}${variantReplacement}${patchedBuilder.slice(variantMatch.index + variantMatch[0].length)}`;
+
+  source = `${source.slice(0, modelBuilderStart)}${patchedBuilder}${source.slice(modelBuilderStart + modelBuilderSource.length)}`;
+  const helper = `${cursorLocalRuntimeCapabilitiesPatchMarker}function ocxCursorFastVariants(e,t,n){if(!t)return e;const r=e.length>0?e:[{parameterValues:[],displayName:n,displayNameOutsidePicker:n,isMaxMode:!1,isDefaultNonMaxConfig:!0,isDefaultMaxConfig:!0}];return r.flatMap(e=>[{...e,parameterValues:[...(e.parameterValues??[]),{id:"fast",value:"false"}]},{...e,parameterValues:[...(e.parameterValues??[]),{id:"fast",value:"true"}],displayName:e.displayName+" Fast",displayNameOutsidePicker:(e.displayNameOutsidePicker??e.displayName)+" Fast",isDefaultNonMaxConfig:!1,isDefaultMaxConfig:!1}])}`;
+  return `${source.slice(0, builderStart)}${helper}${source.slice(builderStart)}`;
+}
+
+function patchCursorLocalRuntimeProviderCapabilities(source) {
+  return replaceSingleMatch(source, localRuntimeProviderPickerInput, (match) => {
+    const { model, reasoning } = match.groups;
+    return `supportsReasoning:${reasoning},reasoningEfforts:Array.isArray(${model}.capabilities?.reasoning_effort)?${model}.capabilities.reasoning_effort:void 0,supportsFast:!0===${model}.capabilities?.supports_fast,supportsVision:`;
+  }, "standalone local provider picker mapper");
+}
+
+export function patchCursorLocalRuntimeSource(source) {
+  if (source.includes(cursorLocalRuntimeCapabilitiesPatchMarker)) return { status: "already-patched", source };
+  if (source.includes(legacyCursorLocalRuntimeCapabilitiesPatchMarker)) {
+    const upgraded = patchCursorLocalRuntimeProviderCapabilities(source).replace(
+      legacyCursorLocalRuntimeCapabilitiesPatchMarker,
+      cursorLocalRuntimeCapabilitiesPatchMarker,
+    );
+    return { status: "patched", source: upgraded };
+  }
+  const displayPatched = patchCursorLocalRuntimeDisplayName(source);
+  return { status: "patched", source: patchCursorLocalRuntimeCapabilities(displayPatched) };
+}
+
+export async function cursorWorkbenchSignature(file = cursorWorkbenchFile) {
+  const value = await stat(file);
+  return `${value.dev}:${value.ino}:${value.size}:${value.mtimeMs}`;
+}
+
+async function writePatchedFile(file, source, patched, backupDirectory) {
+  if (patched.status === "already-patched") {
+    return { status: patched.status, signature: await cursorWorkbenchSignature(file), backupPath: null };
+  }
+
+  await mkdir(backupDirectory, { recursive: true });
+  const digest = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  const backupPath = join(backupDirectory, `${basename(file)}.${digest}.bak`);
+  await copyFile(file, backupPath);
+
+  const mode = (await stat(file)).mode & 0o777;
+  const temporary = `${file}.ocx-cursor-${process.pid}`;
+  await writeFile(temporary, patched.source, { mode });
+  await chmod(temporary, mode);
+  await rename(temporary, file);
+  return { status: patched.status, signature: await cursorWorkbenchSignature(file), backupPath };
+}
+
+export async function ensureCursorWorkbenchPatched(options = {}) {
+  const file = options.file || cursorWorkbenchFile;
+  const backupDirectory = options.backupDirectory || cursorPatchBackupDirectory;
+  const source = await readFile(file, "utf8");
+  const patched = patchCursorBundleSource(source, {
+    preserveCatalogMetadata: options.preserveCatalogMetadata ?? true,
+  });
+  return await writePatchedFile(file, source, patched, backupDirectory);
+}
+
+export async function ensureCursorLocalRuntimesPatched(options = {}) {
+  const files = options.files || cursorLocalRuntimeFiles;
+  const backupDirectory = options.backupDirectory || cursorPatchBackupDirectory;
+  return await Promise.all(files.map(async (file) => {
+    const source = await readFile(file, "utf8");
+    return {
+      file,
+      ...await writePatchedFile(file, source, patchCursorLocalRuntimeSource(source), backupDirectory),
+    };
+  }));
+}
+
+export async function ensureCursorBundlesPatched(options = {}) {
+  const files = options.files || cursorBundleFiles;
+  return await Promise.all(files.map(async (file) => ({
+    file,
+    ...await ensureCursorWorkbenchPatched({
+      ...options,
+      file,
+      preserveCatalogMetadata: isCursorModelMetadataBundle(file),
+    }),
+  })));
+}
+
+export async function ensureCursorAppPatched(options = {}) {
+  const [bundles, runtimes] = await Promise.all([
+    ensureCursorBundlesPatched({
+      ...options,
+      files: options.bundleFiles,
+    }),
+    ensureCursorLocalRuntimesPatched({
+      ...options,
+      files: options.localRuntimeFiles,
+    }),
+  ]);
+  return [...bundles, ...runtimes];
+}
+
+async function ensureCursorPatchFile(file, localRuntimeFiles, options) {
+  if (localRuntimeFiles.has(file)) {
+    const [result] = await ensureCursorLocalRuntimesPatched({
+      ...options,
+      files: [file],
+    });
+    return result;
+  }
+  return {
+    file,
+    ...await ensureCursorWorkbenchPatched({
+      ...options,
+      file,
+      preserveCatalogMetadata: options.file ? true : isCursorModelMetadataBundle(file),
+    }),
+  };
+}
+
+export function startCursorPatchMonitor(options = {}) {
+  const intervalMs = options.intervalMs || 250;
+  const bundleFiles = options.file ? [options.file] : (options.bundleFiles || options.files || cursorBundleFiles);
+  const runtimeFiles = options.file ? [] : (options.localRuntimeFiles || cursorLocalRuntimeFiles);
+  const files = [...bundleFiles, ...runtimeFiles];
+  const localRuntimeFiles = new Set(runtimeFiles);
+  const lastSignatures = new Map();
+  let patchPromise = null;
+  let stopped = false;
+
+  const check = async () => {
+    if (stopped || patchPromise || options.shouldPatch?.() === false) return patchPromise;
+    patchPromise = Promise.all(files.map(async (file) => {
+      let signature;
+      try {
+        signature = await cursorWorkbenchSignature(file);
+      } catch {
+        return;
+      }
+      if (signature === lastSignatures.get(file)) return;
+      try {
+        const result = await ensureCursorPatchFile(file, localRuntimeFiles, options);
+        lastSignatures.set(file, result.signature);
+        options.onResult?.(result);
+      } catch (error) {
+        if (!transientPatchErrorCodes.has(error.code)) lastSignatures.set(file, signature);
+        options.onError?.(error, file);
+      }
+    })).finally(() => {
+      patchPromise = null;
+    });
+    return patchPromise;
+  };
+
+  const timer = setInterval(check, intervalMs);
+  void check();
+  return {
+    check,
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    },
+  };
+}

package/src/cursor-state.mjs

@@ -5,6 +5,45 @@ import { effortLabels } from "./catalog.mjs";
 import { cursorDatabaseFile, installRoot, managedPrefix, pendingFile } from "./paths.mjs";
 
 const storageKey = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
+const displayWords = new Map([
+  ["claude", "Claude"],
+  ["codex", "Codex"],
+  ["composer", "Composer"],
+  ["deepseek", "DeepSeek"],
+  ["fable", "Fable"],
+  ["fast", "Fast"],
+  ["flash", "Flash"],
+  ["gpt", "GPT"],
+  ["grok", "Grok"],
+  ["hy3", "HY3"],
+  ["kimi", "Kimi"],
+  ["luna", "Luna"],
+  ["max", "Max"],
+  ["mimo", "MiMo"],
+  ["mini", "Mini"],
+  ["opus", "Opus"],
+  ["pro", "Pro"],
+  ["qwen", "Qwen"],
+  ["sol", "Sol"],
+  ["sonnet", "Sonnet"],
+  ["spark", "Spark"],
+  ["terra", "Terra"],
+]);
+
+function displayWord(value) {
+  const known = displayWords.get(value);
+  if (known) return known;
+  const attachedVersion = /^(qwen|kimi|gpt|claude|grok)(\d+(?:\.\d+)*)$/.exec(value);
+  if (attachedVersion) return `${displayWords.get(attachedVersion[1])} ${attachedVersion[2]}`;
+  if (/^v\d/i.test(value)) return `V${value.slice(1)}`;
+  if (/^k\d/i.test(value)) return `K${value.slice(1)}`;
+  if (/^\d/.test(value)) return value;
+  return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+
+export function displayNameFor(model) {
+  return model.sourceId.split("/").at(-1).split("-").map(displayWord).join(" ");
+}
 
 export function cursorIsRunning() {
   try {
@@ -62,13 +101,14 @@ function fastDefinition() {
 function modelVariants(model) {
   const parameterId = parameterIdFor(model);
   const selectedDefault = defaultEffort(model);
+  const modelDisplayName = displayNameFor(model);
   const efforts = model.reasoningEfforts.length > 0 ? model.reasoningEfforts : [null];
   const fastValues = model.supportsFast ? ["false", "true"] : [null];
   return efforts.flatMap((effort) => fastValues.map((fast) => {
     const labels = [effort ? effortLabels[effort] : null, fast === "true" ? "Fast" : null].filter(Boolean);
     const displayName = labels.length > 0
-      ? `${model.alias} <span style="color: var(--cursor-text-tertiary);">${labels.join(" ")}</span>`
-      : model.alias;
+      ? `${modelDisplayName} <span style="color: var(--cursor-text-tertiary);">${labels.join(" ")}</span>`
+      : modelDisplayName;
     const isDefault = (effort === null || effort === selectedDefault) && fast !== "true";
     const parameters = [
       ...(effort ? [{ id: parameterId, value: effort }] : []),
@@ -91,8 +131,10 @@ export function cursorModel(model) {
   const hasEffort = model.reasoningEfforts.length > 0;
   const hasVariants = hasEffort || model.supportsFast;
   const variants = hasVariants ? modelVariants(model) : [];
+  const displayName = displayNameFor(model);
   return {
     name: model.alias,
+    clientDisplayName: displayName,
     defaultOn: false,
     supportsAgent: true,
     degradationStatus: 0,
@@ -105,7 +147,7 @@ export function cursorModel(model) {
     supportsPlanMode: true,
     supportsSandboxing: true,
     isUserAdded: true,
-    inputboxShortModelName: model.alias,
+    inputboxShortModelName: displayName,
     idAliases: [],
     namedModelSectionIndex: 1,
     cloudAgentEffortModes: [],

package/src/gateway.mjs

@@ -36,6 +36,15 @@ function suppliedFast(variantText) {
     .find(([key]) => key === "fast")?.[1];
 }
 
+function disableStrictFunctionTools(tools) {
+  if (!Array.isArray(tools)) return;
+  for (const tool of tools) {
+    if (!isRecord(tool) || tool.type !== "function") continue;
+    const definition = isRecord(tool.function) ? tool.function : tool;
+    if (definition.strict === true) definition.strict = false;
+  }
+}
+
 export function rewriteModelAliasBody(body, catalog) {
   if (!body?.length) return body;
   let payload;
@@ -71,6 +80,7 @@ export function rewriteModelAliasBody(body, catalog) {
   if (catalogModel?.supportsFast && fast === "true") payload.service_tier = "priority";
   if (catalogModel?.supportsFast && fast === "false") delete payload.service_tier;
   delete payload.reasoningEffort;
+  disableStrictFunctionTools(payload.tools);
   return Buffer.from(JSON.stringify(payload));
 }
 

package/src/install.mjs

@@ -4,6 +4,8 @@ import { access, chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readlink,
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { ensureCursorAppPatched } from "./cursor-patch.mjs";
+import { cursorIsRunning } from "./cursor-state.mjs";
 import {
   cliLinkFile,
   installRoot,
@@ -165,6 +167,7 @@ function launchAgent(nodePath) {
 export async function installService() {
   await mkdir(dirname(launchAgentFile), { recursive: true });
   const { legacyPlist, secretStatus } = await prepareInstallSecret();
+  const cursorPatches = cursorIsRunning() ? null : await ensureCursorAppPatched();
   await copyPackage();
   await installCliLink();
 
@@ -179,7 +182,7 @@ export async function installService() {
     await rm(disabled, { force: true });
     await rename(legacyPlist, disabled);
   }
-  return { installRoot, launchAgentFile, cliLinkFile, secretStatus };
+  return { installRoot, launchAgentFile, cliLinkFile, secretStatus, cursorPatches };
 }
 
 export async function updateService(options = {}) {

package/src/paths.mjs

@@ -14,6 +14,24 @@ export const stderrFile = join(installRoot, "service.error.log");
 export const launchAgentFile = join(homedir(), "Library", "LaunchAgents", `${serviceLabel}.plist`);
 export const legacyLaunchAgentFile = join(homedir(), "Library", "LaunchAgents", `${legacyServiceLabel}.plist`);
 export const cursorDatabaseFile = join(homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+export const cursorAppOutDirectory = "/Applications/Cursor.app/Contents/Resources/app/out";
+export const cursorWorkbenchFile = join(cursorAppOutDirectory, "vs", "workbench", "workbench.desktop.main.js");
+export const cursorGlassWorkbenchFile = join(cursorAppOutDirectory, "vs", "workbench", "workbench.glass.main.js");
+export const cursorLocalRuntimeFiles = [
+  "/Applications/Cursor.app/Contents/Resources/app/extensions/cursor-local-agent-runtime/dist/main.js",
+  "/Applications/Cursor.app/Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js",
+];
+export const cursorBundleFiles = [
+  join(cursorAppOutDirectory, "main.js"),
+  join(cursorAppOutDirectory, "vs", "code", "electron-utility", "alwaysLocalSingleton", "alwaysLocalSingletonMain.js"),
+  join(cursorAppOutDirectory, "vs", "code", "electron-utility", "mcpProcess", "mcpProcessMain.js"),
+  join(cursorAppOutDirectory, "vs", "code", "electron-utility", "sharedProcess", "sharedProcessMain.js"),
+  join(cursorAppOutDirectory, "vs", "workbench", "api", "node", "extensionHostProcess.js"),
+  join(cursorAppOutDirectory, "vs", "workbench", "api", "worker", "extensionHostWorkerMain.js"),
+  cursorWorkbenchFile,
+  cursorGlassWorkbenchFile,
+];
+export const cursorPatchBackupDirectory = join(installRoot, "cursor-app-backups");
 export const codexHome = process.env.CODEX_HOME || join(homedir(), ".codex");
 export const codexConfigFile = join(codexHome, "config.toml");
 export const defaultCodexCatalogFile = join(codexHome, "opencodex-catalog.json");
@@ -21,5 +39,6 @@ export const opencodexConfigFile = join(homedir(), ".opencodex", "config.json");
 export const opencodexServiceTokenFile = join(homedir(), ".opencodex", "service-api-token");
 export const gatewayPort = Number(process.env.OCX_CURSOR_PORT || "10101");
 export const gatewayHost = process.env.OCX_CURSOR_HOST || "127.0.0.1";
+export const cursorLocalBaseUrl = `http://127.0.0.1:${gatewayPort}/v1`;
 export const cursorOpenAIBaseUrl = process.env.OCX_CURSOR_BASE_URL || "";
 export const managedPrefix = "opencodex/";

package/src/service.mjs

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { buildActiveCatalog } from "./catalog.mjs";
+import { startCursorPatchMonitor } from "./cursor-patch.mjs";
 import {
   cursorIsRunning,
   readPendingCatalog,
@@ -58,6 +59,14 @@ export async function runService(options = {}) {
   }
 
   const server = startGateway({ secret, getCatalog: () => catalog, host: options.host, port: options.port });
+  const patchMonitor = startCursorPatchMonitor({
+    intervalMs: options.cursorPatchIntervalMs,
+    shouldPatch: () => !cursorIsRunning(),
+    onResult: (result) => {
+      if (result.status === "patched") process.stdout.write(`Patched Cursor app file ${result.file} (backup: ${result.backupPath})\n`);
+    },
+    onError: (error, file) => process.stderr.write(`Cursor patch failed for ${file}: ${error.message}\n`),
+  });
   const refreshTimer = setInterval(refresh, options.refreshIntervalMs || 15_000);
   const pendingTimer = setInterval(() => {
     if (cursorSyncPromise) return;
@@ -85,6 +94,7 @@ export async function runService(options = {}) {
     stopped = true;
     clearInterval(refreshTimer);
     clearInterval(pendingTimer);
+    patchMonitor.stop();
     server.close(() => process.exit(0));
   };
   process.on("SIGTERM", stop);

package/src/setup.mjs

@@ -1,24 +1,33 @@
 export function normalizeBaseUrl(value) {
   if (!value) {
-    throw new Error("Enter your Cloudflare Tunnel URL or pass --base-url https://your-domain.example/v1");
+    throw new Error("Enter an endpoint URL or pass --base-url http://127.0.0.1:10101/v1");
   }
 
-  const candidate = value.includes("://") ? value : `https://${value}`;
+  const trimmed = value.trim();
+  const loopbackWithoutScheme = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])(?::|\/|$)/i.test(trimmed);
+  const candidate = trimmed.includes("://")
+    ? trimmed
+    : `${loopbackWithoutScheme ? "http" : "https"}://${trimmed}`;
   let url;
   try {
     url = new URL(candidate);
   } catch {
-    throw new Error(`Invalid Cloudflare Tunnel URL: ${value}`);
+    throw new Error(`Invalid endpoint URL: ${value}`);
   }
 
-  if (url.protocol !== "https:") throw new Error("Cloudflare Tunnel URL must use HTTPS");
+  const isLoopback = url.hostname === "localhost"
+    || url.hostname === "[::1]"
+    || /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback)) {
+    throw new Error("Endpoint URL must use HTTPS unless it points to localhost");
+  }
   if (url.username || url.password || url.search || url.hash) {
-    throw new Error("Cloudflare Tunnel URL cannot contain credentials, a query, or a fragment");
+    throw new Error("Endpoint URL cannot contain credentials, a query, or a fragment");
   }
 
   const pathname = url.pathname.replace(/\/+$/, "");
   if (pathname && pathname !== "/v1") {
-    throw new Error("Cloudflare Tunnel URL must be a hostname or end with /v1");
+    throw new Error("Endpoint URL must be an origin or end with /v1");
   }
   url.pathname = "/v1";
   return url.toString().replace(/\/$/, "");
@@ -43,7 +52,7 @@ async function checkedJson(fetchImpl, url, options, label) {
   }
 }
 
-export async function testTunnel(baseUrl, secret, options = {}) {
+export async function testEndpoint(baseUrl, secret, options = {}) {
   baseUrl = normalizeBaseUrl(baseUrl);
   const fetchImpl = options.fetchImpl || fetch;
   const origin = new URL(baseUrl).origin;
@@ -52,7 +61,7 @@ export async function testTunnel(baseUrl, secret, options = {}) {
   let healthError;
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
-      health = await checkedJson(fetchImpl, `${origin}/healthz`, {}, "Tunnel health check");
+      health = await checkedJson(fetchImpl, `${origin}/healthz`, {}, "Endpoint health check");
       break;
     } catch (error) {
       healthError = error;
@@ -63,14 +72,14 @@ export async function testTunnel(baseUrl, secret, options = {}) {
   }
   if (!health) throw healthError;
   if (health?.service !== "opencodex-cursor-bridge" || health?.status !== "ok") {
-    throw new Error(`Tunnel health check reached an unexpected service at ${origin}/healthz`);
+    throw new Error(`Endpoint health check reached an unexpected service at ${origin}/healthz`);
   }
 
   const models = await checkedJson(fetchImpl, `${baseUrl}/models`, {
     headers: { authorization: `Bearer ${secret}` },
-  }, "Tunnel model check");
+  }, "Endpoint model check");
   if (!Array.isArray(models?.data)) {
-    throw new Error(`Tunnel model check returned an invalid catalog from ${baseUrl}/models`);
+    throw new Error(`Endpoint model check returned an invalid catalog from ${baseUrl}/models`);
   }
 
   return { health, modelCount: models.data.length };