@closedrouter/cli 1.1.10 → 1.1.11

package/dist/index.js

@@ -5204,7 +5204,7 @@ var {
 } = exports_commander;
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 
 // ../node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs
 import { stripVTControlCharacters as S2 } from "node:util";
@@ -8659,9 +8659,9 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { spawn as spawn5 } from "node:child_process";
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname4, join as join16 } from "node:path";
+import { dirname as dirname5, join as join16 } from "node:path";
 
 // src/model-picker.ts
 import { emitKeypressEvents as emitKeypressEvents2 } from "node:readline";
@@ -9418,6 +9418,112 @@ async function settingsCommand(options = {}) {
 import { randomUUID } from "node:crypto";
 import { createServer as createServer2, request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+
+// src/commands/launch-catalog.ts
+import { createHash as createHash2 } from "node:crypto";
+var modelLabel = (id) => `ClosedRouter: ${id}`;
+function transportModelId(id, family) {
+  const hash = createHash2("sha256").update(id).digest("hex").slice(0, 20);
+  return `${family === "claude" ? "claude-sonnet-4-6" : "gemini"}-closedrouter-${hash}`;
+}
+function createLaunchCatalog(models, selected) {
+  const ids = [...new Set([selected, ...models])];
+  return {
+    defaultModel: selected,
+    models: ids,
+    aliases: Object.fromEntries(ids.flatMap((id) => [
+      [transportModelId(id, "claude"), id],
+      [transportModelId(id, "gemini"), id]
+    ])),
+    fallbacks: ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "gemini-3.8-flash", "gemini-3.8-flash-medium", "gemini-3.8-flash-high", "gemini-2.5-flash", "gemini-2.5-flash-lite"]
+  };
+}
+function resolveLaunchModel(catalog, requested) {
+  let id = requested.replace(/^models\//, "").replace(/\[1m\]$/, "");
+  const fireworks = /^accounts\/fireworks\/models\/(.+)#anysphere\/[\w-]+$/.exec(id);
+  if (fireworks)
+    id = fireworks[1];
+  if (catalog.models.includes(id))
+    return id;
+  if (id.startsWith("closedrouter/") && catalog.models.includes(id.slice(13)))
+    return id.slice(13);
+  if (Object.hasOwn(catalog.aliases, id))
+    return catalog.aliases[id];
+  if (catalog.fallbacks.includes(id))
+    return catalog.defaultModel;
+  return;
+}
+function claudeModelPicker(models) {
+  return { replaceBuiltInOptions: true, options: models.map((id) => ({ model: id, label: modelLabel(id), description: "Via your ClosedRouter pool", behavesAs: "claude-sonnet-4-6" })) };
+}
+function codexModelCatalog(models) {
+  return { models: models.map((id, priority) => ({
+    slug: id,
+    display_name: modelLabel(id),
+    description: "Via your ClosedRouter pool",
+    priority,
+    visibility: "list",
+    supported_in_api: true,
+    supported_reasoning_levels: [],
+    experimental_supported_tools: [],
+    base_instructions: "You are a coding assistant working with the user in their workspace. Follow the user's task and applicable project instructions. Inspect relevant files before editing, preserve unrelated work, and verify changes with appropriate checks. Use the available tools when needed. Report the outcome and any material limitations clearly. The runtime supplies the configured inference model identity through ClosedRouter.",
+    default_reasoning_level: null,
+    supports_reasoning_summaries: false,
+    default_reasoning_summary: "none",
+    shell_type: "shell_command",
+    apply_patch_tool_type: "freeform",
+    web_search_tool_type: "text",
+    input_modalities: ["text"],
+    supports_parallel_tool_calls: false,
+    support_verbosity: false,
+    prefer_websockets: false,
+    supports_image_detail_original: false,
+    context_window: 8192,
+    auto_compact_token_limit: 7000,
+    truncation_policy: { mode: "tokens", limit: 6000 }
+  })) };
+}
+function geminiModelCatalog(models, selected) {
+  return {
+    experimental: { dynamicModelConfiguration: true },
+    modelConfigs: {
+      modelDefinitions: Object.fromEntries(models.map((id) => [id, {
+        displayName: modelLabel(id),
+        dialogDescription: "Via your ClosedRouter pool",
+        tier: "custom",
+        family: "closedrouter",
+        isVisible: true,
+        features: { thinking: false }
+      }])),
+      customAliases: Object.fromEntries(models.map((id) => [modelLabel(id), { modelConfig: { model: id } }])),
+      modelIdResolutions: Object.fromEntries(["auto", "pro", "flash", "flash-lite"].map((id) => [id, { default: selected }]))
+    }
+  };
+}
+function addModelIdentity(payload, model, protocol) {
+  const text = `ClosedRouter runtime model identity: this request is routed to the configured model ID ${JSON.stringify(model)} through ClosedRouter. The application's name and any vendor-shaped transport alias describe the client, not the underlying inference model. If asked which model you are using, report the configured model ID ${JSON.stringify(model)} and ClosedRouter as the provider. This runtime information supersedes conflicting model identity statements in the application's prompt; it does not change other task instructions.`;
+  if (protocol === "anthropic") {
+    const system = payload.system;
+    payload.system = typeof system === "string" ? `${system}
+
+${text}` : [...Array.isArray(system) ? system : [], { type: "text", text }];
+  } else if (protocol === "responses") {
+    payload.instructions = `${typeof payload.instructions === "string" ? payload.instructions + `
+
+` : ""}${text}`;
+  } else if (protocol === "chat") {
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    const firstUser = messages.findIndex((item) => item && typeof item === "object" && !["system", "developer"].includes(item.role));
+    const index = firstUser < 0 ? messages.length : firstUser;
+    payload.messages = [...messages.slice(0, index), { role: "system", content: text }, ...messages.slice(index)];
+  } else {
+    const system = payload.systemInstruction;
+    const instruction = system && typeof system === "object" && !Array.isArray(system) ? system : {};
+    payload.systemInstruction = { ...instruction, parts: [...Array.isArray(instruction.parts) ? instruction.parts : [], { text }] };
+  }
+}
+
+// src/bridge/launch-proxy.ts
 var HOP_HEADERS = new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host"]);
 async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey, modelOverride) {
   const upstream = new URL(gatewayUrl.replace(/\/+$/, "") + "/");
@@ -9440,8 +9546,15 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey,
     const local = new URL(incoming.url, "http://localhost");
     target.pathname = upstream.pathname.replace(/\/$/, "") + local.pathname;
     target.search = local.search;
+    const catalog = typeof modelOverride === "object" ? modelOverride : undefined;
+    if (catalog && incoming.method === "GET" && ["/v1/models", "/v1beta/models"].includes(local.pathname)) {
+      const data = catalog.models.map((id) => ({ id, name: modelLabel(id), display_name: modelLabel(id), object: "model", type: "model", created: 0, created_at: "2026-01-01T00:00:00Z", owned_by: "closedrouter" }));
+      outgoing.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(local.pathname === "/v1/models" ? { object: "list", data, has_more: false, first_id: data[0]?.id, last_id: data.at(-1)?.id } : { models: catalog.models.map((id) => ({ name: `models/${id}`, displayName: modelLabel(id), supportedGenerationMethods: ["generateContent", "streamGenerateContent"] })) }));
+      return;
+    }
     let rewrittenBody;
-    if (modelOverride && incoming.method === "POST" && /^\/v1\/(?:messages(?:\/count_tokens)?|chat\/completions|responses)$/.test(local.pathname)) {
+    const gemini = /^\/v1beta\/models\/(.+):(generateContent|streamGenerateContent)$/.exec(local.pathname);
+    if (modelOverride && incoming.method === "POST" && (gemini || /^\/v1\/(?:messages(?:\/count_tokens)?|chat\/completions|responses)$/.test(local.pathname))) {
       try {
         const chunks = [];
         let length = 0;
@@ -9459,8 +9572,18 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey,
           return;
         }
         const payload = body;
-        const tinyProbe = local.pathname === "/v1/messages" && !modelOverride.startsWith("claude-") && payload.model !== modelOverride && typeof payload.max_tokens === "number" && payload.max_tokens <= 16 && Array.isArray(payload.messages) && payload.messages.length === 1 && (!Array.isArray(payload.tools) || payload.tools.length === 0);
-        rewrittenBody = JSON.stringify({ ...payload, model: modelOverride, ...tinyProbe ? { max_tokens: 512 } : {} });
+        const requested = gemini ? decodeURIComponent(gemini[1]) : typeof payload.model === "string" ? payload.model : catalog?.defaultModel || "";
+        const model = catalog ? resolveLaunchModel(catalog, requested) : modelOverride;
+        if (!model) {
+          outgoing.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: { type: "invalid_request_error", message: "This model is not in this launch's ClosedRouter catalog. Choose a supported model from the picker." } }));
+          return;
+        }
+        const tinyProbe = local.pathname === "/v1/messages" && !model.startsWith("claude-") && payload.model !== model && typeof payload.max_tokens === "number" && payload.max_tokens <= 16 && Array.isArray(payload.messages) && payload.messages.length === 1 && (!Array.isArray(payload.tools) || payload.tools.length === 0);
+        if (catalog)
+          addModelIdentity(payload, model, gemini ? "gemini" : local.pathname.startsWith("/v1/messages") ? "anthropic" : local.pathname === "/v1/responses" ? "responses" : "chat");
+        if (gemini)
+          target.pathname = upstream.pathname.replace(/\/$/, "") + `/v1beta/models/${encodeURIComponent(model)}:${gemini[2]}`;
+        rewrittenBody = JSON.stringify({ ...payload, ...!gemini ? { model } : {}, ...tinyProbe ? { max_tokens: 512 } : {} });
       } catch {
         outgoing.writeHead(400).end();
         return;
@@ -9529,7 +9652,7 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey,
 import { createServer as createServer3 } from "node:http";
 import { request as httpRequest2 } from "node:http";
 import { request as httpsRequest2 } from "node:https";
-async function startAgyModelProxy(gatewayUrl, apiKey, model) {
+async function startAgyModelProxy(gatewayUrl, apiKey, model, catalog) {
   const upstream = new URL(gatewayUrl.replace(/\/+$/, "") + "/");
   if (!["https:", "http:"].includes(upstream.protocol)) {
     throw new Error("ClosedRouter server URL must use HTTP or HTTPS.");
@@ -9541,12 +9664,17 @@ async function startAgyModelProxy(gatewayUrl, apiKey, model) {
       return;
     }
     const requestUrl = new URL(incoming.url || "/", "http://localhost");
-    const match = /^\/v1beta\/models\/[^/:]+:(generateContent|streamGenerateContent)$/.exec(requestUrl.pathname);
+    const match = /^\/v1beta\/models\/([^/:]+):(generateContent|streamGenerateContent)$/.exec(requestUrl.pathname);
     if (incoming.method !== "POST" || !match) {
       outgoing.writeHead(404).end();
       return;
     }
-    const target = new URL(`v1beta/models/${encodeURIComponent(model)}:${match[1]}${requestUrl.search}`, upstream);
+    const selected = catalog ? resolveLaunchModel(catalog, decodeURIComponent(match[1])) : model;
+    if (!selected) {
+      outgoing.writeHead(400).end(JSON.stringify({ error: { message: "Choose a supported ClosedRouter model." } }));
+      return;
+    }
+    const target = new URL(`v1beta/models/${encodeURIComponent(selected)}:${match[2]}${requestUrl.search}`, upstream);
     const headers = { ...incoming.headers, host: target.host, "x-goog-api-key": apiKey };
     const upstreamRequest = requestUpstream(target, { method: "POST", headers }, (response) => {
       outgoing.writeHead(response.statusCode || 502, response.headers);
@@ -9586,28 +9714,26 @@ import { join as join9 } from "node:path";
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function registerAgyLaunchModel(homeDir, model, transportModel) {
+function registerAgyLaunchCatalog(homeDir, catalog, legacyTransport) {
   const path = join9(homeDir, ".gemini", "antigravity-cli", "settings.json");
   const settings = JSON.parse(readFileSync8(path, "utf8"));
-  if (!record(settings) || settings.modelProvider !== "gemini") {
+  if (!record(settings) || settings.modelProvider !== "gemini")
     throw new Error(`Set "modelProvider": "gemini" in ${path} before starting Antigravity through ClosedRouter.`);
-  }
   const config = settings.customModelsConfig ?? {};
   if (!record(config))
     throw new Error(`customModelsConfig must be an object in ${path}.`);
-  const models = config.customModels ?? {};
-  if (!record(models))
+  const previous = config.customModels ?? {};
+  if (!record(previous))
     throw new Error(`customModelsConfig.customModels must be an object in ${path}.`);
-  const label = `ClosedRouter: ${model}`;
-  const entry = { modelName: transportModel, apiProvider: "gemini" };
-  const existing = models[label];
-  if (existing !== undefined) {
-    if (!record(existing) || existing.modelName !== transportModel || existing.apiProvider !== "gemini" || Object.keys(existing).some((key) => !["modelName", "apiProvider"].includes(key))) {
+  const models = { ...previous };
+  for (const id of catalog.models) {
+    const label = modelLabel(id), name = transportModelId(id, "gemini"), existing = previous[label];
+    if (existing !== undefined && (!record(existing) || existing.apiProvider !== "gemini" || ![name, legacyTransport].includes(String(existing.modelName)) || Object.keys(existing).some((key) => !["modelName", "apiProvider"].includes(key)))) {
       throw new Error(`The custom model '${label}' already has different settings in ${path}. Rename that entry before launching it with ClosedRouter.`);
     }
-    return label;
+    models[label] = { modelName: name, apiProvider: "gemini" };
   }
-  settings.customModelsConfig = { ...config, customModels: { ...models, [label]: entry } };
+  settings.customModelsConfig = { ...config, customModels: models };
   const temporary = `${path}.closedrouter-${randomUUID2()}.tmp`;
   try {
     writeFileSync2(temporary, `${JSON.stringify(settings, null, 2)}
@@ -9617,7 +9743,7 @@ function registerAgyLaunchModel(homeDir, model, transportModel) {
     if (existsSync9(temporary))
       unlinkSync(temporary);
   }
-  return label;
+  return modelLabel(catalog.defaultModel);
 }
 
 // src/commands/cursor-launch.ts
@@ -9815,7 +9941,7 @@ function createDesktopProfile(tool) {
   mkdirSync2(root, { recursive: true, mode: 448 });
   return mkdtempSync(join11(root, "session-"));
 }
-function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey, model, toolArgs = [], platform = process.platform) {
+function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey, model, toolArgs = [], platform = process.platform, models = model ? [model] : []) {
   validateDesktopArgs(toolArgs);
   const env = { ...process.env };
   delete env.ELECTRON_RUN_AS_NODE;
@@ -9835,6 +9961,8 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
       `model = ${JSON.stringify(model)}`,
       'model_provider = "closedrouter"',
       "",
+      `model_catalog_json = ${JSON.stringify(join11(codexHome, "closedrouter-models.json"))}`,
+      "",
       "[model_providers.closedrouter]",
       'name = "ClosedRouter"',
       `base_url = ${JSON.stringify(`${baseUrl.replace(/\/+$/, "")}/v1`)}`,
@@ -9844,11 +9972,11 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
     ].join(`
 `) });
     files.push({ path: join11(codexHome, "auth.json"), contents: JSON.stringify({ auth_mode: "apikey", OPENAI_API_KEY: localKey }) });
+    files.push({ path: join11(codexHome, "closedrouter-models.json"), contents: JSON.stringify(codexModelCatalog([...new Set([model, ...models])])) });
   }
   if (tool === "claude" && baseUrl && localKey && model) {
     userData = join11(profileDir, "user-data-3p");
     const id = randomUUID3();
-    const transportModel = model.startsWith("claude-") || model.startsWith("anthropic/claude-") ? model : "claude-sonnet-4-6";
     const json = (value) => `${JSON.stringify(value, null, 2)}
 `;
     files.push({ path: join11(userData, "claude_desktop_config.json"), contents: json({ deploymentMode: "3p" }) });
@@ -9859,7 +9987,7 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
       inferenceGatewayApiKey: localKey,
       inferenceGatewayAuthScheme: "bearer",
       disableDeploymentModeChooser: true,
-      inferenceModels: [{ name: transportModel, labelOverride: `ClosedRouter: ${model}` }]
+      inferenceModels: [...new Set([model, ...models])].map((id) => ({ name: transportModelId(id, "claude"), labelOverride: modelLabel(id) }))
     }) });
   }
   Object.assign(env, appEnv);
@@ -9970,8 +10098,9 @@ function defaultCursorDatabase() {
   const root = process.platform === "darwin" ? join12(homedir11(), "Library", "Application Support") : process.platform === "win32" ? process.env.APPDATA || join12(homedir11(), "AppData", "Roaming") : join12(homedir11(), ".config");
   return join12(root, "Cursor", "User", "globalStorage", "state.vscdb");
 }
-async function configureCursorDesktop(profileDir, baseUrl, apiKey, model, sourceDb = process.env.CLOSEDROUTER_CURSOR_AUTH_DB ?? defaultCursorDatabase()) {
+async function configureCursorDesktop(profileDir, baseUrl, apiKey, model, sourceDb = process.env.CLOSEDROUTER_CURSOR_AUTH_DB ?? defaultCursorDatabase(), models = [model]) {
   const cursorModel = model;
+  const catalog = [...new Set([model, ...models])];
   const dbPath = join12(profileDir, "user-data", "User", "globalStorage", "state.vscdb");
   mkdirSync3(dirname2(dbPath), { recursive: true, mode: 448 });
   const items = new Map;
@@ -9992,14 +10121,14 @@ async function configureCursorDesktop(profileDir, baseUrl, apiKey, model, source
   items.set(CURSOR_APPLICATION_STORAGE, JSON.stringify({
     useOpenAIKey: true,
     openAIBaseUrl: `${baseUrl.replace(/\/+$/, "")}/v1`,
-    availableAPIKeyModels: [cursorModel],
+    availableAPIKeyModels: catalog,
     havePerformedSettingsServiceMigration: true,
-    localProviderModelIds: [cursorModel],
-    localProviderAgentModelIds: [cursorModel],
+    localProviderModelIds: catalog,
+    localProviderAgentModelIds: catalog,
     ...membershipType ? { membershipType } : {},
     aiSettings: {
-      userAddedModels: [cursorModel],
-      modelOverrideEnabled: [cursorModel],
+      userAddedModels: catalog,
+      modelOverrideEnabled: catalog,
       modelOverrideDisabled: [],
       modelConfig: Object.fromEntries(["cmd-k", "composer", "background-composer", "plan-execution", "spec", "quick-agent"].map((feature) => [feature, { modelName: cursorModel, maxMode: false, selectedModels: [{ modelId: cursorModel, parameters: [] }] }]))
     }
@@ -10024,6 +10153,129 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { join as join13 } from "node:path";
+
+// src/commands/agy-desktop-catalog.ts
+function patchAntigravityCatalog(source, catalog) {
+  const provider = /this\.customModelsProvider=([\w$]+)\(this\.rootProvider,([\w$]+)=>\(\{customModels:\2\.appState\?\.customModelsConfig\?\.customModels\?\?\{\}\}\)\)/;
+  const context = /function ([\w$]+)\(\{children:([\w$]+),userStatus:([\w$]+),lastSelectedAgentModel:([\w$]+),setLastSelectedAgentModel:/;
+  const match = context.exec(source);
+  if (!provider.test(source) || !match)
+    throw new Error("This Antigravity build has an unsupported custom-model picker. Update the ClosedRouter launcher.");
+  const entries = catalog.models.map((id) => [`ClosedRouter: ${id}`, Object.keys(catalog.aliases).find((alias) => alias.startsWith("gemini-closedrouter-") && catalog.aliases[alias] === id)]);
+  const models = `Object.fromEntries(${JSON.stringify(entries)}.map(([label,id])=>[label,r(I.ModelInfoSchema,{modelId:I.Model.GOOGLE_GEMINI_INTERNAL_BYOM,apiProvider:I.APIProvider.API_PROVIDER_GOOGLE_EVERGREEN,chatModelName:label,modelName:id,maxTokens:32768,maxOutputTokens:4096,supportsContext:true,modelFeatures:r(I.ModelFeaturesSchema,{zeroShotCapable:true,supportsToolCalls:true,supportsImages:false,supportsThinking:false})})]))`;
+  const customState = /([\w$]+)=!!([\w$]+),([\w$]+)=\(0,([\w$]+)\.useMemo\)\(\(\)=>\(\{customModels:([\w$]+)\?\.customModels\?\?([\w$]+)\}\),\[\5\]\)/;
+  if (!customState.test(source))
+    throw new Error("This Antigravity build has an unsupported custom-model context.");
+  source = source.replace(customState, (_all, supported, _feature, state, react, input) => `${supported}=true,${state}=(0,${react}.useMemo)(()=>({customModels:${models}}),[${input}])`);
+  const customHeader = /showCustomModelHeader:[\w$]+,onAddCustomModel:/;
+  if (!customHeader.test(source))
+    throw new Error("This Antigravity build has an unsupported custom-model menu.");
+  source = source.replace(/showCustomModelHeader:[\w$]+,onAddCustomModel:[\w$]+,onEditCustomModel:[\w$]+/, "showCustomModelHeader:true,onAddCustomModel:undefined,onEditCustomModel:undefined");
+  source = source.replace(/([\w$]+)=([\w$]+)\.some\(([\w$]+)=>\3\.options\.length>0\);([\w$]+)=/, "$1=true;$4=");
+  source = source.replace(provider, (_all, selector, variable) => `this.customModelsProvider=${selector}(this.rootProvider,${variable}=>({customModels:${models}}))`);
+  const start = source.indexOf(match[0]);
+  const end = source.indexOf(`function `, start + match[0].length);
+  let body = source.slice(start, end);
+  const state = /\[([\w$]+),([\w$]+)\]=\(0,([\w$]+)\.useState\)\(null\)/;
+  if (!state.test(body) || !body.includes("clientModelConfigs||[]"))
+    throw new Error("This Antigravity build has an unsupported model-selection context.");
+  body = body.replace(state, (_all, value, setter, react) => `[${value},${setter}]=(0,${react}.useState)(${JSON.stringify(`ClosedRouter: ${catalog.defaultModel}`)})`).replace(/\([\w$]+\?\.cascadeModelConfigData\?\.clientModelConfigs\|\|\[\]\)/g, "([])").replace(/[\w$]+\?\.clientModelConfigs\|\|\[\]/g, "[]").replace(/[\w$]+\?\.clientModelSorts\|\|\[\]/g, "[]");
+  return source.slice(0, start) + body + source.slice(end);
+}
+function antigravityCatalogHook(catalog, marker) {
+  return `
+const {app} = require('electron');
+const patchCatalog = ${patchAntigravityCatalog.toString()};
+app.on('web-contents-created', (_event, contents) => {
+  const debuggerClient = contents.debugger;
+  try {
+    debuggerClient.attach('1.3');
+    debuggerClient.sendCommand('Fetch.enable', {patterns:[{urlPattern:'https://127.0.0.1:*/main.js',requestStage:'Response'}]}).catch(() => {});
+    debuggerClient.on('message', async (_event, method, params) => {
+      if (method !== 'Fetch.requestPaused') return;
+      try {
+        const url = new URL(params.request.url);
+        if (url.hostname !== '127.0.0.1' || url.pathname !== '/main.js' || params.responseStatusCode !== 200) {
+          await debuggerClient.sendCommand('Fetch.continueRequest', {requestId:params.requestId}); return;
+        }
+        const result = await debuggerClient.sendCommand('Fetch.getResponseBody', {requestId:params.requestId});
+        const source = result.base64Encoded ? Buffer.from(result.body,'base64').toString('utf8') : result.body;
+        const patched = patchCatalog(source, ${JSON.stringify(catalog)});
+        await debuggerClient.sendCommand('Fetch.fulfillRequest', {requestId:params.requestId,responseCode:200,
+          responseHeaders:(params.responseHeaders || []).filter(h=>!['content-length','content-encoding','transfer-encoding'].includes(h.name.toLowerCase())),
+          body:Buffer.from(patched).toString('base64')});
+        require('node:fs').writeFileSync(${JSON.stringify(marker)}, 'ready', {mode:0o600});
+        await debuggerClient.sendCommand('Fetch.disable');
+        debuggerClient.detach();
+      } catch (error) {
+        require('node:fs').writeFileSync(${JSON.stringify(marker + ".error")}, String(error.message), {mode:0o600});
+        await debuggerClient.sendCommand('Fetch.failRequest', {requestId:params.requestId,errorReason:'Failed'}).catch(()=>{});
+      }
+    });
+  } catch (error) {
+    require('node:fs').writeFileSync(${JSON.stringify(marker + ".error")}, String(error.message), {mode:0o600});
+  }
+});
+`;
+}
+
+// src/commands/model-branding.ts
+var CLOSEDROUTER_LOGO = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect width="24" height="24" rx="6" fill="#D4FE51"/><path d="M16.68 7.82A6.5 6.5 0 1 0 16.68 16.18" fill="none" stroke="#04080A" stroke-width="2.6" stroke-linecap="round"/><circle cx="18.2" cy="12" r="1.9" fill="#04080A"/></svg>';
+function installModelBranding(models, artwork) {
+  if (document.querySelector("[data-closedrouter-branding]"))
+    return;
+  const marker = document.createElement("meta");
+  marker.dataset.closedrouterBranding = "true";
+  document.head.append(marker);
+  const paint = () => {
+    for (const element of document.querySelectorAll('button,[role="button"],[role="option"],[role="menuitem"],[role="menuitemradio"],[data-testid="model-selector-item"]')) {
+      const text = element.innerText.trim().split(`
+`)[0];
+      if (!models.some((id) => text === id || text === `ClosedRouter: ${id}`))
+        continue;
+      const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        const node = walker.currentNode;
+        const value = node.textContent || "";
+        if (models.some((id) => value.trim() === `ClosedRouter: ${id}`))
+          node.textContent = value.replace("ClosedRouter: ", "");
+      }
+      if (element.querySelector(":scope > [data-closedrouter-logo]"))
+        continue;
+      const logo = document.createElement("img");
+      logo.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(artwork)}`;
+      logo.alt = "ClosedRouter";
+      logo.title = "Routed through ClosedRouter";
+      logo.dataset.closedrouterLogo = "true";
+      logo.style.cssText = "width:16px;height:16px;flex:0 0 16px;display:inline-block;vertical-align:middle;margin-inline-end:6px;pointer-events:none";
+      element.prepend(logo);
+    }
+  };
+  let scheduled = false;
+  const observer = new MutationObserver(() => {
+    if (scheduled)
+      return;
+    scheduled = true;
+    requestAnimationFrame(() => {
+      scheduled = false;
+      paint();
+    });
+  });
+  observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
+  paint();
+}
+function modelBrandingHook(models) {
+  const script = `(${installModelBranding.toString()})(${JSON.stringify(models)},${JSON.stringify(CLOSEDROUTER_LOGO)})`;
+  return `
+require('electron').app.on('web-contents-created', (_event, contents) => {
+  contents.on('did-finish-load', () => {
+    contents.executeJavaScript(${JSON.stringify(script)}).catch(() => {});
+  });
+});
+`;
+}
+
+// src/commands/agy-desktop.ts
 var MODS_CONTROL_URL = "http://127.0.0.1:59998";
 var MODS_PROXY_URL = "http://127.0.0.1:59997";
 async function assertAntigravityModsAvailable() {
@@ -10060,7 +10312,7 @@ function assertAntigravityDesktopHookSupport(executable) {
   if (index < 0 || binary[index + 32 + 5] !== 49)
     throw new Error("This Antigravity build disables launch inspector hooks. Use --open-only.");
 }
-async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_PROXY_URL) {
+async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_PROXY_URL, catalog) {
   const capability = randomUUID4();
   const controllers = new Set;
   const server = createServer4(async (incoming, outgoing) => {
@@ -10099,9 +10351,15 @@ async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_
           return;
         }
         const body = JSON.parse(raw.toString("utf8"));
+        const requested = body.modelName || body.model || model;
+        const selected = catalog ? resolveLaunchModel(catalog, requested) : model;
+        if (!selected) {
+          outgoing.writeHead(400).end(JSON.stringify({ error: { message: "Choose a supported ClosedRouter model." } }));
+          return;
+        }
         const request = body.request || body;
         payload = Buffer.from(JSON.stringify(request));
-        target = `${gatewayUrl}/v1beta/models/${encodeURIComponent(model)}:${generation[1]}${generation[1] === "streamGenerateContent" ? "?alt=sse" : ""}`;
+        target = `${gatewayUrl}/v1beta/models/${encodeURIComponent(selected)}:${generation[1]}${generation[1] === "streamGenerateContent" ? "?alt=sse" : ""}`;
         headers.authorization = `Bearer ${localKey}`;
         headers["content-type"] = "application/json";
       } else {
@@ -10182,8 +10440,9 @@ async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_
     })
   };
 }
-function addAntigravityDesktopHook(plan, endpoint) {
+function addAntigravityDesktopHook(plan, endpoint, catalog) {
   const path = join13(plan.profileDir, "antigravity-hook.cjs");
+  const marker = join13(plan.profileDir, "model-catalog-ready");
   const contents = `const cp = require('node:child_process');
 const spawn = cp.spawn;
 cp.spawn = function(command, args, options) {
@@ -10205,10 +10464,10 @@ cp.spawn = function(command, args, options) {
   return spawn.call(this, command, args, options);
 };
 require('node:fs').writeFileSync(${JSON.stringify(join13(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
-`;
+` + (catalog ? antigravityCatalogHook(catalog, marker) + modelBrandingHook(catalog.models) : "");
   plan.files.push({ path, contents });
   const logPath = join13(plan.profileDir, "inspector.log");
-  plan.inspectorHook = { path, logPath };
+  plan.inspectorHook = { path, logPath, ...catalog ? { readyPath: marker } : {} };
   plan.args.push("--inspect-brk=127.0.0.1:0");
   if (plan.command === "/usr/bin/open") {
     const index = plan.args.indexOf("--args");
@@ -10218,9 +10477,89 @@ require('node:fs').writeFileSync(${JSON.stringify(join13(plan.profileDir, "hook-
 
 // src/commands/claude-desktop.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync14, readdirSync as readdirSync2 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { copyFileSync, existsSync as existsSync14, linkSync, lstatSync, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync12, readdirSync as readdirSync2, readlinkSync, realpathSync, renameSync as renameSync2, rmSync, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { join as join14 } from "node:path";
+import { dirname as dirname3, join as join14, relative as relative2 } from "node:path";
+function cloneClaudeElectronRuntime(source, destination) {
+  const clone = (from, to) => {
+    const info = lstatSync(from);
+    if (info.isSymbolicLink())
+      symlinkSync(readlinkSync(from), to);
+    else if (info.isDirectory()) {
+      mkdirSync4(to, { mode: 448 });
+      for (const name of readdirSync2(from))
+        clone(join14(from, name), join14(to, name));
+    } else if (info.isFile())
+      linkSync(from, to);
+    else
+      throw new Error("Unsupported file in the shared Electron runtime.");
+  };
+  clone(source, destination);
+  const contents = join14(destination, "Contents");
+  const roots = [contents, ...readdirSync2(join14(contents, "Frameworks")).filter((name) => name.endsWith(".app")).map((name) => join14(contents, "Frameworks", name, "Contents"))];
+  const owned = [];
+  for (const root of roots) {
+    if (!realpathSync(root).startsWith(realpathSync(destination) + "/"))
+      throw new Error("Electron helper signing must stay inside the owned runtime.");
+    for (const name of readdirSync2(join14(root, "MacOS"))) {
+      const target = join14(root, "MacOS", name);
+      if (!lstatSync(target).isFile())
+        throw new Error("Electron helper executables must be regular files.");
+      const original = join14(source, relative2(destination, target));
+      unlinkSync2(target);
+      copyFileSync(original, target);
+      owned.push(target);
+    }
+    rmSync(join14(root, "_CodeSignature"), { recursive: true, force: true });
+  }
+  return owned;
+}
+function prepareClaudeElectronRuntime(runtime, sourceApp) {
+  const source = dirname3(dirname3(dirname3(realpathSync(runtime))));
+  if (!source.endsWith(".app"))
+    throw new Error("Claude's shared runtime must be a macOS Electron app bundle.");
+  const framework = join14(source, "Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework");
+  const fingerprint = createHash3("sha256").update(JSON.stringify({
+    schema: 1,
+    source,
+    sourceApp,
+    executable: statSync2(runtime).mtimeMs,
+    framework: statSync2(framework).mtimeMs,
+    appInfo: readFileSync12(join14(sourceApp, "Contents/Info.plist"), "utf8")
+  })).digest("hex").slice(0, 24);
+  const root = join14(getConfigDir(), "desktop-runtime", "claude");
+  mkdirSync4(root, { recursive: true, mode: 448 });
+  const cache = join14(root, fingerprint), app = join14(cache, "Electron.app");
+  const executable = join14(app, "Contents/MacOS", runtime.split("/").at(-1));
+  const marker = join14(cache, "ready.json");
+  if (existsSync14(marker)) {
+    const saved = JSON.parse(readFileSync12(marker, "utf8"));
+    if (saved.fingerprint !== fingerprint || saved.source !== source)
+      throw new Error("Claude's owned runtime cache has unexpected metadata.");
+    execFileSync2("/usr/bin/codesign", ["--verify", app], { stdio: "pipe" });
+    return executable;
+  }
+  const staging = mkdtempSync2(join14(root, ".preparing-"));
+  try {
+    const target = join14(staging, "Electron.app");
+    const owned = cloneClaudeElectronRuntime(source, target);
+    const entitlements = join14(staging, "entitlements.plist");
+    writeFileSync4(entitlements, '<?xml version="1.0"?><plist version="1.0"><dict><key>com.apple.security.cs.allow-jit</key><true/><key>com.apple.security.cs.disable-library-validation</key><true/><key>com.apple.security.virtualization</key><true/></dict></plist>', { mode: 384 });
+    for (const path of [...owned.slice(1), owned[0]]) {
+      if (statSync2(path).nlink !== 1)
+        throw new Error("Refusing to sign a shared Electron executable.");
+      execFileSync2("/usr/bin/codesign", ["--force", "--sign", "-", "--entitlements", entitlements, path], { stdio: "pipe" });
+    }
+    execFileSync2("/usr/bin/codesign", ["--verify", target], { stdio: "pipe" });
+    writeFileSync4(join14(staging, "ready.json"), JSON.stringify({ fingerprint, source, sourceApp }), { mode: 384 });
+    renameSync2(staging, cache);
+    return executable;
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    throw new Error("Could not prepare Claude's lightweight runtime. The shared runtime and ClosedRouter config directory must be on the same filesystem, with codesign available.", { cause: error });
+  }
+}
 function findClaudeSharedElectron(sourceApp, home = homedir13()) {
   const explicit = process.env.CLOSEDROUTER_CLAUDE_ELECTRON || process.env.CLAUDE_DESKTOP_AUTH_ELECTRON;
   if (explicit && existsSync14(explicit))
@@ -10233,11 +10572,12 @@ function findClaudeSharedElectron(sourceApp, home = homedir13()) {
   const versions = readdirSync2(root).filter((version) => version.startsWith(`${major}.`)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
   return versions.map((version) => join14(root, version, `darwin-${process.arch}`, "Electron.app/Contents/MacOS/Electron")).find((path) => existsSync14(path));
 }
-function useClaudeSharedElectron(plan, runtime, sourceApp, toolArgs = []) {
-  plan.command = runtime;
-  plan.args = [join14(sourceApp, "Contents/Resources/app.asar"), `--user-data-dir=${join14(plan.profileDir, "user-data-3p")}`, ...toolArgs];
+function useClaudeSharedElectron(plan, runtime, sourceApp, toolArgs = [], launchServices = false) {
+  const args = [join14(sourceApp, "Contents/Resources/app.asar"), `--user-data-dir=${join14(plan.profileDir, "user-data-3p")}`, ...toolArgs];
+  plan.command = launchServices ? "/usr/bin/open" : runtime;
+  plan.args = launchServices ? ["-W", "-n", "-a", dirname3(dirname3(dirname3(runtime))), "--args", ...args] : args;
 }
-function addClaudeDesktopHook(plan, baseUrl, localKey, sourceApp) {
+function addClaudeDesktopHook(plan, baseUrl, localKey, sourceApp, models) {
   const path = join14(plan.profileDir, "claude-hook.cjs");
   plan.files.push({ path, contents: `${sourceApp ? `const electron = require('electron');
 Object.defineProperty(process, 'resourcesPath', {value: ${JSON.stringify(join14(sourceApp, "Contents/Resources"))}});
@@ -10260,7 +10600,7 @@ if (autoUpdater) {
   autoUpdater.quitAndInstall = () => {};
 }
 require('node:fs').writeFileSync(${JSON.stringify(join14(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
-` });
+` + (models ? modelBrandingHook(models) : "") });
   const logPath = join14(plan.profileDir, "inspector.log");
   plan.inspectorHook = { path, logPath };
   plan.args.push("--inspect-brk=127.0.0.1:0");
@@ -10269,30 +10609,69 @@ require('node:fs').writeFileSync(${JSON.stringify(join14(plan.profileDir, "hook-
 }
 
 // src/commands/cursor-desktop-hook.ts
-import { readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname3, join as join15 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { dirname as dirname4, join as join15 } from "node:path";
 var FLAGS = /([\w$]+)=\{extensionIsDev:[^{}]{1,1000}localMode:(?:!1|false)\}/;
-function addCursorDesktopLocalHook(plan, app) {
-  const resources = app.endsWith(".app") ? join15(app, "Contents/Resources/app") : join15(dirname3(app), "resources/app");
+function addCursorDesktopLocalHook(plan, app, catalog) {
+  const resources = app.endsWith(".app") ? join15(app, "Contents/Resources/app") : join15(dirname4(app), "resources/app");
   const source = join15(resources, "out/main.js");
-  const renderer = join15(resources, "out/vs/workbench/workbench.desktop.main.js");
-  const mainSource = readFileSync12(source, "utf8");
-  const rendererSource = readFileSync12(renderer, "utf8");
+  const mainSource = readFileSync13(source, "utf8");
   const mainMatch = FLAGS.exec(mainSource);
-  const rendererMatch = FLAGS.exec(rendererSource);
-  if (!mainMatch || !rendererMatch || !rendererSource.includes("runLocalAgentInExtensionHost"))
+  if (!mainMatch)
     throw new Error("This Cursor Desktop build does not include the supported local agent runtime. Update Cursor or use cr start cursor with Cursor Agent Local.");
   const nativeKey = mainMatch[1];
-  const authMethod = "isAuthenticated(){const e=this.accessToken(),t=this.refreshToken();return this.scheduleTeamPolicyCheck(),!!(e&&t)}";
-  if (!rendererSource.includes(authMethod))
-    throw new Error("This Cursor Desktop build has an unsupported login controller. Update the ClosedRouter launcher before using local provider mode.");
-  const modifiedRenderer = rendererSource.replace(rendererMatch[0], rendererMatch[0].replace(/localMode:(?:!1|false)/, "localMode:!0")).replace(authMethod, `isAuthenticated(){const e=this.accessToken(),t=this.refreshToken();if(!e&&!t&&${rendererMatch[1]}.localMode&&this.byokProviderKeyStorage?.openAIKey()&&this._reactiveStorageService.applicationUserPersistentStorage.openAIBaseUrl)return true;return this.scheduleTeamPolicyCheck(),!!(e&&t)}`);
-  const patched = join15(plan.profileDir, "cursor-local-workbench.js");
+  const redirects = {};
+  for (const variant of ["desktop", "glass"]) {
+    const renderer = join15(resources, `out/vs/workbench/workbench.${variant}.main.js`);
+    if (!existsSync15(renderer) && variant === "glass")
+      continue;
+    const rendererSource = readFileSync13(renderer, "utf8");
+    const rendererMatch = FLAGS.exec(rendererSource);
+    if (!rendererMatch || !rendererSource.includes("runLocalAgentInExtensionHost"))
+      throw new Error("This Cursor Desktop build does not include the supported local agent runtime. Update Cursor or use cr start cursor with Cursor Agent Local.");
+    const authMethod = /isAuthenticated\(\)\{const ([\w$]+)=this\.accessToken\(\),([\w$]+)=this\.refreshToken\(\);return this\.scheduleTeamPolicyCheck\(\),!!\(\1&&\2\)\}/;
+    if (!authMethod.test(rendererSource))
+      throw new Error("This Cursor Desktop build has an unsupported login controller. Update the ClosedRouter launcher before using local provider mode.");
+    let modifiedRenderer = rendererSource.replace(rendererMatch[0], rendererMatch[0].replace(/localMode:(?:!1|false)/, "localMode:!0")).replace(authMethod, `isAuthenticated(){const e=this.accessToken(),t=this.refreshToken();if(!e&&!t&&${rendererMatch[1]}.localMode&&this.byokProviderKeyStorage?.openAIKey()&&this._reactiveStorageService.applicationUserPersistentStorage.openAIBaseUrl)return true;return this.scheduleTeamPolicyCheck(),!!(e&&t)}`);
+    if (catalog) {
+      const nativeCatalog = "getAvailableDefaultModels(){return[...this._availableDefaultModels()]}";
+      if (!modifiedRenderer.includes(nativeCatalog))
+        throw new Error("This Cursor Desktop build has an unsupported model catalog controller. Update the ClosedRouter launcher.");
+      const entries = catalog.models.map((id) => ({
+        name: id,
+        serverModelName: id,
+        clientDisplayName: id,
+        inputboxShortModelName: id,
+        defaultOn: true,
+        supportsAgent: true,
+        supportsPlanMode: true,
+        supportsNonMaxMode: true,
+        supportsImages: false,
+        supportsThinking: false,
+        supportsCmdK: true,
+        supportsSmartModeClassifier: true,
+        parameterDefinitions: [],
+        variants: [],
+        legacySlugs: [],
+        idAliases: [],
+        namedModelSectionIndex: 0,
+        tooltipData: { markdownContent: "Via your ClosedRouter pool" }
+      }));
+      modifiedRenderer = modifiedRenderer.replace(nativeCatalog, `getAvailableDefaultModels(){return ${JSON.stringify(entries)}}`);
+      const display = /function ([\w$]+)\(([\w$]+),([\w$]+),([\w$]+)\)\{if\(\2\.includes\(","\)\)/;
+      if (!display.test(modifiedRenderer))
+        throw new Error("This Cursor Desktop build has an unsupported model-label formatter. Update the ClosedRouter launcher.");
+      modifiedRenderer = modifiedRenderer.replace(display, (all, _fn, model) => all.replace("{if(", `{if(${JSON.stringify(catalog.models)}.includes(${model}))return 'ClosedRouter: '+${model};if(`));
+    }
+    const patched = join15(plan.profileDir, `cursor-local-workbench${variant === "desktop" ? "" : "-glass"}.js`);
+    redirects[renderer] = patched;
+    plan.files.push({ path: patched, contents: modifiedRenderer });
+  }
   const hook = join15(plan.profileDir, "cursor-local-hook.cjs");
   const marker = join15(plan.profileDir, "main-local-mode-enabled");
-  plan.files.push({ path: patched, contents: modifiedRenderer });
   plan.files.push({ path: hook, contents: `const {app, session} = require('electron');
 const fs = require('node:fs');
+const redirects = ${JSON.stringify(redirects)};
 function installProtocolHook() {
   const protocol = session.defaultSession.protocol;
   const prototype = Object.getPrototypeOf(protocol);
@@ -10300,9 +10679,9 @@ function installProtocolHook() {
   prototype.registerFileProtocol = function(scheme, handler, ...rest) {
     if (scheme !== 'vscode-file') return register.call(this, scheme, handler, ...rest);
     return register.call(this, scheme, (request, callback) => handler(request, result => {
-      if (request.url.includes('workbench.desktop.main.js')) fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "renderer-request.json"))}, JSON.stringify({type: typeof result, path: result?.path}), {mode: 0o600});
-      if (result && typeof result === 'object' && result.path === ${JSON.stringify(renderer)}) {
-        result = {...result, path: ${JSON.stringify(patched)}};
+      if (/workbench.(?:desktop|glass).main.js/.test(request.url)) fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "renderer-request.json"))}, JSON.stringify({type: typeof result, path: result?.path}), {mode: 0o600});
+      if (result && typeof result === 'object' && Object.hasOwn(redirects, result.path)) {
+        result = {...result, path: redirects[result.path]};
         fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "renderer-local-mode-served"))}, 'ready', {mode: 0o600});
       }
       callback(result);
@@ -10312,7 +10691,7 @@ function installProtocolHook() {
 }
 if (app.isReady()) installProtocolHook(); else app.once('ready', installProtocolHook);
 require('node:fs').writeFileSync(${JSON.stringify(join15(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
-` });
+` + (catalog ? modelBrandingHook(catalog.models) : "") });
   const point = mainSource.slice(0, mainMatch.index + mainMatch[0].length).split(`
 `);
   const logPath = join15(plan.profileDir, "inspector.log");
@@ -10348,7 +10727,7 @@ var TOOL_OPTIONS = [
 var DESKTOP_TOOL_OPTIONS = [
   { value: "codex-desktop", label: "Codex Desktop", hint: "Responses API with an isolated app profile" },
   { value: "antigravity-desktop", label: "Antigravity Desktop", hint: "ClosedRouter routing through your antigravity-mods hook" },
-  { value: "cursor-desktop", label: "Cursor Desktop", hint: "Automatic API-key setup; requires a public gateway" },
+  { value: "cursor-desktop", label: "Cursor Desktop", hint: "Local model engine using your ClosedRouter pool" },
   { value: "claude-desktop", label: "Claude Desktop", hint: "Inference gateway with an isolated app profile" }
 ];
 function getStartToolOptions(desktopOnly = false) {
@@ -10378,7 +10757,7 @@ function assertNoManagedCodexArgs(args) {
     throw new Error(`Remove ${conflicting}; ClosedRouter manages the Codex profile and model. Put other arguments after --.`);
   }
 }
-function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir = homedir14(), executablePath, agyRouting) {
+function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir = homedir14(), executablePath, agyRouting, catalog) {
   const baseUrl = normalizeServerUrl(serverUrl);
   const env = { ...process.env };
   const command = executablePath || tool;
@@ -10398,7 +10777,7 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
     return {
       tool,
       command,
-      args: ["--model", model, ...toolArgs],
+      args: ["--model", model, ...catalog ? ["--settings", JSON.stringify({ modelPicker: claudeModelPicker(catalog.models) })] : [], ...toolArgs],
       env
     };
   }
@@ -10407,9 +10786,11 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
     const codexHome = process.env.CODEX_HOME || join16(homeDir, ".codex");
     const profileName = "closedrouter-launch";
     const configPath = join16(codexHome, `${profileName}.config.toml`);
+    const catalogPath = join16(codexHome, "closedrouter-models.json");
     const configLines = [
       `model = ${tomlString(model)}`,
       `model_provider = ${tomlString(profileName)}`,
+      ...catalog ? [`model_catalog_json = ${tomlString(catalogPath)}`] : [],
       "",
       `[model_providers.${profileName}]`,
       `name = ${tomlString("ClosedRouter")}`,
@@ -10425,7 +10806,8 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
       args: ["--profile", profileName, ...toolArgs],
       env,
       configFile: { path: configPath, contents: configLines.join(`
-`) }
+`) },
+      ...catalog ? { extraFiles: [{ path: catalogPath, contents: JSON.stringify(codexModelCatalog(catalog.models)) }] } : {}
     };
   }
   if (tool === "gemini") {
@@ -10441,7 +10823,7 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
       env,
       configFile: {
         path: configPath,
-        contents: `${JSON.stringify({ security: { auth: { selectedType: "gemini-api-key" } } }, null, 2)}
+        contents: `${JSON.stringify({ security: { auth: { selectedType: "gemini-api-key" } }, ...catalog ? geminiModelCatalog(catalog.models, model) : {} }, null, 2)}
 `
       }
     };
@@ -10467,8 +10849,9 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
     return {
       tool,
       command,
-      args: ["--model", `openai/${model}`, ...toolArgs],
-      env
+      args: ["--model", `openai/${catalog ? "closedrouter/" : ""}${model}`, ...catalog ? ["--model-metadata-file", join16(homeDir, ".closedrouter", "aider-models.json")] : [], ...toolArgs],
+      env,
+      ...catalog ? { configFile: { path: join16(homeDir, ".closedrouter", "aider-models.json"), contents: JSON.stringify(Object.fromEntries(catalog.models.map((id) => [`openai/closedrouter/${id}`, { litellm_provider: "openai", mode: "chat", max_input_tokens: 8192, max_output_tokens: 4096, supports_function_calling: true }]))) } } : {}
     };
   }
   const config = {
@@ -10481,7 +10864,7 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
           baseURL: `${baseUrl}/v1`,
           apiKey: "{env:CLOSEDROUTER_API_KEY}"
         },
-        models: { [model]: { name: model } }
+        models: Object.fromEntries((catalog?.models || [model]).map((id) => [id, { name: modelLabel(id) }]))
       }
     }
   };
@@ -10495,9 +10878,9 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
   };
 }
 function writeOwnedConfig(file) {
-  mkdirSync4(dirname4(file.path), { recursive: true, mode: 448 });
+  mkdirSync5(dirname5(file.path), { recursive: true, mode: 448 });
   try {
-    const existing = readFileSync13(file.path, "utf8");
+    const existing = readFileSync14(file.path, "utf8");
     if (file.path.endsWith(".config.toml") && !existing.includes('name = "ClosedRouter"')) {
       throw new Error(`Refusing to replace an existing Codex profile at ${file.path}.`);
     }
@@ -10505,7 +10888,7 @@ function writeOwnedConfig(file) {
     if (error instanceof Error && error.message.startsWith("Refusing to replace"))
       throw error;
   }
-  writeFileSync4(file.path, file.contents, { encoding: "utf8", mode: 384 });
+  writeFileSync5(file.path, file.contents, { encoding: "utf8", mode: 384 });
 }
 function modelSupportsHarness(model, tool) {
   const parameters = model.supported_parameters;
@@ -10536,7 +10919,7 @@ function assertAgyCustomModel(command, label, apiKey) {
 function assertAgyGeminiMode(homeDir) {
   const settingsPath = join16(homeDir, ".gemini", "antigravity-cli", "settings.json");
   try {
-    const settings = JSON.parse(readFileSync13(settingsPath, "utf8"));
+    const settings = JSON.parse(readFileSync14(settingsPath, "utf8"));
     if (settings?.modelProvider === "gemini")
       return;
   } catch {}
@@ -10600,11 +10983,12 @@ async function startCommand(options = {}) {
   }
   if (desktop && tool === "claude") {
     assertClaudeDesktopGatewaySupport(executablePath);
-    if (options.desktopInspector && process.platform === "darwin" && executablePath.endsWith(".app")) {
+    if (process.platform === "darwin" && executablePath.endsWith(".app")) {
       sharedClaudeElectron = findClaudeSharedElectron(executablePath);
-      if (sharedClaudeElectron)
-        M2.info("Using the shared Electron runtime for Claude's startup inspector. The installed app bundle is reused.");
-      else
+      if (sharedClaudeElectron) {
+        sharedClaudeElectron = prepareClaudeElectronRuntime(sharedClaudeElectron, executablePath);
+        M2.info("Using the lightweight Claude launcher with Cowork virtualization support. Existing framework files are shared.");
+      } else if (options.desktopInspector)
         throw new Error("No compatible shared Electron runtime was found. Set CLOSEDROUTER_CLAUDE_ELECTRON to an installed Electron executable or omit --desktop-inspector to use Claude's native gateway mode.");
     }
   }
@@ -10643,14 +11027,15 @@ async function startCommand(options = {}) {
   if (!isGatewayModelAvailable(availableModels, model)) {
     throw new Error(`Model '${model}' is not available for ${tool} with this platform key. Agent clients require a provider that supports gateway function tools. Choose another model from ClosedRouter's model catalog.`);
   }
+  const catalog = createLaunchCatalog(availableModels, model);
   if (desktop && tool === "cursor") {
     const localKey = randomUUID5();
-    const relay = await startLaunchProxy(serverUrl, apiKey, "cursor-desktop", localKey, model);
+    const relay = await startLaunchProxy(serverUrl, apiKey, "cursor-desktop", localKey, catalog);
     try {
       const plan = buildDesktopLaunchPlan("cursor", executablePath, createDesktopProfile("cursor"), undefined, undefined, undefined, options.toolArgs);
-      addCursorDesktopLocalHook(plan, executablePath);
+      addCursorDesktopLocalHook(plan, executablePath, catalog);
       writeDesktopLaunchPlan(plan);
-      await configureCursorDesktop(plan.profileDir, relay.baseUrl, localKey, model);
+      await configureCursorDesktop(plan.profileDir, relay.baseUrl, localKey, model, undefined, catalog.models);
       M2.info(`Starting Cursor desktop local provider mode with ${model}. Model requests use ClosedRouter, without a paid Cursor subscription. Profile: ${plan.profileDir}. Keep cr running until you close this app instance.`);
       process.exitCode = await runDesktopLaunch(plan);
     } finally {
@@ -10660,18 +11045,18 @@ async function startCommand(options = {}) {
   }
   if (desktop && (tool === "codex" || tool === "claude" || tool === "agy")) {
     const localKey = randomUUID5();
-    const relay = await startLaunchProxy(serverUrl, apiKey, `${tool}-desktop`, localKey, tool === "claude" ? model : undefined);
+    const relay = await startLaunchProxy(serverUrl, apiKey, `${tool}-desktop`, localKey, catalog);
     let agyDesktopProxy;
     try {
-      const plan = buildDesktopLaunchPlan(tool, executablePath, createDesktopProfile(tool), relay.baseUrl, localKey, model, options.toolArgs);
-      if (options.desktopInspector && tool === "claude" && executablePath.endsWith(".app") && process.platform === "darwin") {
+      const plan = buildDesktopLaunchPlan(tool, executablePath, createDesktopProfile(tool), relay.baseUrl, localKey, model, options.toolArgs, process.platform, catalog.models);
+      if (sharedClaudeElectron && tool === "claude") {
         if (sharedClaudeElectron)
-          useClaudeSharedElectron(plan, sharedClaudeElectron, sourceApp, options.toolArgs);
-        addClaudeDesktopHook(plan, relay.baseUrl, localKey, sharedClaudeElectron ? sourceApp : undefined);
+          useClaudeSharedElectron(plan, sharedClaudeElectron, sourceApp, options.toolArgs, true);
+        addClaudeDesktopHook(plan, relay.baseUrl, localKey, sourceApp, catalog.models);
       }
       if (tool === "agy") {
-        agyDesktopProxy = await startAgyDesktopProxy(relay.baseUrl, localKey, model);
-        addAntigravityDesktopHook(plan, agyDesktopProxy.baseUrl);
+        agyDesktopProxy = await startAgyDesktopProxy(relay.baseUrl, localKey, model, undefined, catalog);
+        addAntigravityDesktopHook(plan, agyDesktopProxy.baseUrl, catalog);
       }
       writeDesktopLaunchPlan(plan);
       M2.info(`Starting ${tool} desktop with ${model} through ${serverUrl}. Profile: ${plan.profileDir}. Keep cr running until you close this app instance.`);
@@ -10684,16 +11069,18 @@ async function startCommand(options = {}) {
   }
   if (tool === "agy")
     assertAgyGeminiMode(homedir14());
-  const recognizedModel = tool === "agy" ? registerAgyLaunchModel(homedir14(), model, discoverAgyTransportModel(options.executablePath || "agy", apiKey)) : undefined;
+  const recognizedModel = tool === "agy" ? registerAgyLaunchCatalog(homedir14(), catalog, discoverAgyTransportModel(options.executablePath || "agy", apiKey)) : undefined;
   if (recognizedModel)
     assertAgyCustomModel(options.executablePath || "agy", recognizedModel, apiKey);
-  const relay = await startLaunchProxy(serverUrl, apiKey, tool);
+  const relay = await startLaunchProxy(serverUrl, apiKey, tool, apiKey, catalog);
   let agyProxy;
   try {
-    agyProxy = tool === "agy" ? await startAgyModelProxy(relay.baseUrl, apiKey, model) : undefined;
-    const plan = buildLaunchPlan(tool, relay.baseUrl, apiKey, model, options.toolArgs, homedir14(), executablePath, agyProxy && recognizedModel ? { baseUrl: agyProxy.baseUrl, recognizedModel } : undefined);
+    agyProxy = tool === "agy" ? await startAgyModelProxy(relay.baseUrl, apiKey, model, catalog) : undefined;
+    const plan = buildLaunchPlan(tool, relay.baseUrl, apiKey, model, options.toolArgs, homedir14(), executablePath, agyProxy && recognizedModel ? { baseUrl: agyProxy.baseUrl, recognizedModel } : undefined, catalog);
     if (plan.configFile)
       writeOwnedConfig(plan.configFile);
+    for (const file of plan.extraFiles || [])
+      writeOwnedConfig(file);
     M2.info(`${import_picocolors12.default.green("Starting")} ${import_picocolors12.default.bold(TOOL_OPTIONS.find((option) => option.value === tool)?.label || tool)} with ${import_picocolors12.default.cyan(model)} through ${import_picocolors12.default.dim(serverUrl)}`);
     const exitCode = await runTool(plan);
     process.exitCode = exitCode;
@@ -10748,7 +11135,7 @@ process.on("warning", (warning) => {
   console.warn(warning.name, warning.message);
 });
 var program2 = new Command2;
-var cliVersion = JSON.parse(readFileSync14(new URL("../package.json", import.meta.url), "utf8")).version;
+var cliVersion = JSON.parse(readFileSync15(new URL("../package.json", import.meta.url), "utf8")).version;
 program2.name("closedrouter").description("ClosedRouter CLI: Import local AI subscriptions & API keys into your shared token pool").version(cliVersion).option("-s, --server <url>", "ClosedRouter server base URL (default: http://localhost:8000)").action(async (options) => {
   await onboardCommand({ server: options.server });
 });