cursor-openai-byok 1.0.2

package/lib/cli.js

@@ -0,0 +1,1888 @@
+"use strict";
+
+const __bundlePath = require("path");
+const __bundleRoot = __bundlePath.resolve(__dirname, "..");
+const __bundleModules = {
+"src/cli/index.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { configPath } = require("../paths");
+const { DEFAULT_CONFIG, writeDefaultConfig, loadConfig, listModels, redactConfig } = require("../config");
+const { syncCursorStorage } = require("../cursor-models");
+const { tailLog } = require("../logger");
+const service = require("./service");
+const patcher = require("../patcher");
+
+async function main(args) {
+  const command = args[0] || "help";
+  const options = parseOptions(args.slice(1));
+  switch (command) {
+    case "help": return help();
+    case "configure": return configure(options);
+    case "daemon": return service.startForeground();
+    case "start": return print(service.startBackground());
+    case "stop": return print(service.stopBackground());
+    case "restart":
+      service.stopBackground();
+      return print(service.startBackground());
+    case "install": return install(options);
+    case "uninstall": return uninstall(options);
+    case "doctor": return doctor(options);
+    case "logs": return process.stdout.write(tailLog(Number(options.lines || 160)) + "\n");
+    case "models": return print({ models: listModels(loadConfig()) });
+    default:
+      throw new Error(`Unknown command ${command}`);
+  }
+}
+
+function parseOptions(args) {
+  const out = {};
+  for (const arg of args) {
+    if (arg === "--force") out.force = true;
+    else if (arg === "--import-ccursor") out.importCcursor = true;
+    else if (arg.startsWith("--app-root=")) out.appRoot = arg.slice("--app-root=".length);
+    else if (arg.startsWith("--lines=")) out.lines = arg.slice("--lines=".length);
+  }
+  return out;
+}
+
+function help() {
+  console.log(`cursor-openai-byok
+
+Commands:
+  install                 Install Cursor patch and lifecycle extension
+  uninstall               Remove extension and restore Cursor backup
+  configure               Create default config if missing
+  configure --import-ccursor
+                          Import ~/.ccursor/providers.json into this config
+  start|stop|restart      Manage local daemon manually
+  daemon                  Run daemon in foreground
+  doctor                  Check config, daemon, Cursor patch, and provider routing
+  models                  Print configured models
+  logs [--lines=N]        Print daemon log tail
+
+Options:
+  --app-root=PATH         Cursor resources/app path
+  --force                 Allow unsupported Cursor version or legacy patch replacement
+`);
+}
+
+function configure(options = {}) {
+  const file = options.importCcursor ? importCcursorConfig() : writeDefaultConfig();
+  console.log(`Config ready: ${file}`);
+  console.log("Edit apiKey/baseUrl/models before installing if this is a new setup.");
+}
+
+function importCcursorConfig() {
+  const source = path.join(os.homedir(), ".ccursor", "providers.json");
+  if (!fs.existsSync(source)) throw new Error(`${source} not found`);
+  const ccursor = JSON.parse(fs.readFileSync(source, "utf8"));
+  const providers = (ccursor.providers || []).map((provider) => ({
+    id: provider.name || provider.id,
+    name: provider.name || provider.id,
+    type: provider.type === "openai-chat-completions" ? "openai-chat-completions" : "openai-responses",
+    baseUrl: provider.baseUrl,
+    apiKey: provider.auth?.value || provider.apiKey,
+    models: (provider.models || []).map((model) => ({
+      displayName: model.displayName || model.id || model.apiModel,
+      apiModel: model.apiModel || model.displayName || model.id,
+      supportsTools: model.supportsTools !== false,
+      supportsStreaming: model.supportsStreaming !== false,
+      contextTokenLimit: model.contextTokenLimit || model.contextTokenLimitForMaxMode || 128000,
+      maxOutputTokens: model.maxOutputTokens || 8192,
+    })),
+  })).filter((provider) => provider.id && provider.baseUrl && provider.models.length > 0);
+  if (providers.length === 0) throw new Error(`${source} does not contain usable providers`);
+  const config = {
+    ...DEFAULT_CONFIG,
+    defaults: { model: providers[0].models[0].displayName },
+    providers,
+  };
+  fs.mkdirSync(path.dirname(configPath()), { recursive: true });
+  fs.writeFileSync(configPath(), JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+  return configPath();
+}
+
+function install(options) {
+  writeDefaultConfig();
+  const patch = patcher.installPatch(options);
+  const extension = service.installExtension();
+  const storage = syncCursorStorage(listModels(loadConfig()));
+  print({ config: configPath(), patch, extension, storage });
+}
+
+function uninstall(options) {
+  const stopped = service.stopBackground();
+  const extension = service.uninstallExtension();
+  const patch = patcher.uninstallPatch(options);
+  print({ stopped, extension, patch });
+}
+
+async function doctor(options) {
+  const checks = [];
+  let config;
+  try {
+    config = loadConfig();
+    checks.push({ name: "config", ok: true, path: configPath(), models: listModels(config).map((m) => m.displayName) });
+  } catch (err) {
+    checks.push({ name: "config", ok: false, error: err.message });
+  }
+
+  if (config) {
+    checks.push({ name: "config-redacted", ok: true, config: redactConfig(config) });
+    try {
+      checks.push({ name: "cursor-model-storage", ok: true, ...syncCursorStorage(listModels(config)) });
+    } catch (err) {
+      checks.push({ name: "cursor-model-storage", ok: false, error: err.message });
+    }
+  }
+
+  try {
+    const st = patcher.status(options);
+    checks.push({ name: "cursor", ok: st.supportedVersion, ...st });
+  } catch (err) {
+    checks.push({ name: "cursor", ok: false, error: err.message });
+  }
+
+  checks.push({ name: "extension", ok: service.extensionStatus().installed, ...service.extensionStatus() });
+  const runningPid = service.isRunning();
+  checks.push({
+    name: "daemon-process",
+    ok: true,
+    running: !!runningPid,
+    pid: runningPid || undefined,
+    note: runningPid ? "server is running" : "server is expected to run only while Cursor extension is active",
+  });
+
+  try {
+    const cfg = config || loadConfig();
+    const host = cfg.server?.host || "127.0.0.1";
+    const port = cfg.server?.port || 39832;
+    const res = await fetch(`http://${host}:${port}/health`);
+    const json = await res.json();
+    checks.push({ name: "daemon-health", ok: res.ok && json.ok, status: res.status, health: json });
+  } catch (err) {
+    checks.push({
+      name: "daemon-health",
+      ok: !runningPid,
+      running: false,
+      error: err.message,
+      note: runningPid ? "server pid exists but health check failed" : "health is skipped when Cursor is not running",
+    });
+  }
+
+  print({ ok: checks.every((c) => c.ok), checks });
+}
+
+function print(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+module.exports = { main };
+
+},
+"src/paths.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+
+const APP_NAME = "cursor-openai-byok";
+const DEFAULT_PORT = 39832;
+
+function homeDir() {
+  return os.homedir();
+}
+
+function configDir() {
+  return path.join(homeDir(), `.${APP_NAME}`);
+}
+
+function configPath() {
+  return path.join(configDir(), "config.json");
+}
+
+function logPath() {
+  return path.join(configDir(), "daemon.log");
+}
+
+function pidPath() {
+  return path.join(configDir(), "daemon.pid");
+}
+
+function runtimePath(name) {
+  return path.join(configDir(), name);
+}
+
+function platformName() {
+  if (process.platform === "darwin") return "macos";
+  if (process.platform === "win32") return "windows";
+  return process.platform;
+}
+
+function cursorExtensionsDir() {
+  return path.join(homeDir(), ".cursor", "extensions");
+}
+
+function installedExtensionDir() {
+  const version = require("../package.json").version;
+  return path.join(cursorExtensionsDir(), `cursor-openai-byok.cursor-openai-byok-${version}`);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+module.exports = {
+  APP_NAME,
+  DEFAULT_PORT,
+  homeDir,
+  configDir,
+  configPath,
+  logPath,
+  pidPath,
+  runtimePath,
+  platformName,
+  cursorExtensionsDir,
+  installedExtensionDir,
+  ensureDir,
+};
+
+},
+"package.json": function(module, exports, require, __filename, __dirname) {
+module.exports = {
+  "name": "cursor-openai-byok",
+  "version": "1.0.2",
+  "description": "Local BYOK bridge for Cursor using OpenAI-compatible providers.",
+  "displayName": "Cursor OpenAI BYOK",
+  "publisher": "cursor-openai-byok",
+  "type": "commonjs",
+  "main": "./lib/extension.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.3weijia.com/base/ai/cursor-openai-byok.git"
+  },
+  "keywords": [
+    "cursor",
+    "byok",
+    "openai",
+    "openai-compatible",
+    "local-bridge"
+  ],
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/install.sh",
+    "scripts/uninstall.sh",
+    "scripts/install.ps1",
+    "scripts/uninstall.ps1",
+    "config.example.json",
+    "README.md",
+    "TROUBLESHOOTING.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "activationEvents": [
+    "*"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "cursorOpenaiByok.openSettings",
+        "title": "Cursor OpenAI BYOK: Open Settings"
+      },
+      {
+        "command": "cursorOpenaiByok.startServer",
+        "title": "Cursor OpenAI BYOK: Start Server"
+      },
+      {
+        "command": "cursorOpenaiByok.stopServer",
+        "title": "Cursor OpenAI BYOK: Stop Server"
+      },
+      {
+        "command": "cursorOpenaiByok.restartServer",
+        "title": "Cursor OpenAI BYOK: Restart Server"
+      },
+      {
+        "command": "cursorOpenaiByok.showStatus",
+        "title": "Cursor OpenAI BYOK: Show Status"
+      }
+    ]
+  },
+  "bin": {
+    "cursor-openai-byok": "bin/cursor-openai-byok.js"
+  },
+  "scripts": {
+    "build:npm": "node scripts/build-npm.js",
+    "test": "node --test",
+    "doctor": "node bin/cursor-openai-byok.js doctor",
+    "prepack": "npm run build:npm",
+    "package": "npm run build:npm && node scripts/package.js"
+  },
+  "engines": {
+    "vscode": "^1.99.0",
+    "node": ">=20"
+  },
+  "license": "UNLICENSED"
+};
+},
+"src/config.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { configDir, configPath, DEFAULT_PORT } = require("./paths");
+
+const DEFAULT_CONFIG = {
+  $schemaVersion: 1,
+  server: {
+    host: "127.0.0.1",
+    port: DEFAULT_PORT,
+  },
+  defaults: {
+    model: "fastskills-gpt-5.5",
+  },
+  providers: [
+    {
+      id: "fastskills",
+      name: "FastSkills",
+      type: "openai-responses",
+      baseUrl: "https://api-hw.fastskills.ai/v1",
+      apiKey: "sk-REPLACE_ME",
+      models: [
+        {
+          displayName: "fastskills-gpt-5.5",
+          apiModel: "gpt-5.5",
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImages: true,
+        contextTokenLimit: 258000,
+        maxOutputTokens: 32000,
+        },
+      ],
+    },
+  ],
+};
+
+function ensureConfigDir() {
+  fs.mkdirSync(configDir(), { recursive: true });
+}
+
+function writeDefaultConfig(target = configPath()) {
+  ensureConfigDir();
+  if (!fs.existsSync(target)) {
+    fs.writeFileSync(target, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", { mode: 0o600 });
+  }
+  return target;
+}
+
+function readJsonFile(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function loadConfig(file = configPath()) {
+  if (!fs.existsSync(file)) writeDefaultConfig(file);
+  const config = readJsonFile(file);
+  validateConfig(config, file);
+  return config;
+}
+
+function validateConfig(config, file = configPath()) {
+  if (!config || typeof config !== "object") throw new Error(`${file}: config must be an object`);
+  if (!Array.isArray(config.providers) || config.providers.length === 0) {
+    throw new Error(`${file}: providers must be a non-empty array`);
+  }
+  const modelNames = new Set();
+  for (const provider of config.providers) {
+    if (!provider.id || typeof provider.id !== "string") throw new Error(`${file}: provider.id is required`);
+    if (!["openai-responses", "openai-chat-completions"].includes(provider.type)) {
+      throw new Error(`${file}: provider ${provider.id} type must be openai-responses or openai-chat-completions`);
+    }
+    if (!provider.baseUrl || typeof provider.baseUrl !== "string") {
+      throw new Error(`${file}: provider ${provider.id} baseUrl is required`);
+    }
+    const key = resolveApiKey(provider, false);
+    if (!key || key === "sk-REPLACE_ME") {
+      throw new Error(`${file}: provider ${provider.id} apiKey or apiKeyEnv must be configured`);
+    }
+    if (!Array.isArray(provider.models) || provider.models.length === 0) {
+      throw new Error(`${file}: provider ${provider.id} models must be a non-empty array`);
+    }
+    for (const model of provider.models) {
+      if (!model.displayName || typeof model.displayName !== "string") {
+        throw new Error(`${file}: provider ${provider.id} model.displayName is required`);
+      }
+      if (modelNames.has(model.displayName)) {
+        throw new Error(`${file}: duplicate model displayName ${model.displayName}`);
+      }
+      modelNames.add(model.displayName);
+      if (model.apiModel !== undefined && typeof model.apiModel !== "string") {
+        throw new Error(`${file}: model ${model.displayName} apiModel must be a string`);
+      }
+    }
+  }
+}
+
+function resolveApiKey(provider, throwOnMissing = true) {
+  const key = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : provider.apiKey;
+  if ((!key || key === "sk-REPLACE_ME") && throwOnMissing) {
+    throw new Error(`Missing API key for provider ${provider.id}`);
+  }
+  return key;
+}
+
+function listModels(config) {
+  const models = [];
+  for (const provider of config.providers || []) {
+    for (const model of provider.models || []) {
+      models.push({
+        providerId: provider.id,
+        providerName: provider.name || provider.id,
+        providerType: provider.type,
+        displayName: model.displayName,
+        apiModel: model.apiModel || model.displayName,
+        supportsTools: model.supportsTools !== false,
+        supportsStreaming: model.supportsStreaming !== false,
+        supportsImages: model.supportsImages !== false,
+        contextTokenLimit: model.contextTokenLimit || 128000,
+        maxOutputTokens: model.maxOutputTokens || 8192,
+      });
+    }
+  }
+  return models;
+}
+
+function resolveModel(config, requestedModel) {
+  const models = listModels(config);
+  const fallback = config.defaults && config.defaults.model;
+  const target = requestedModel || fallback || (models[0] && models[0].displayName);
+  const found = models.find((m) => m.displayName === target || m.apiModel === target);
+  if (!found) {
+    throw new Error(`Model ${target || "<empty>"} is not configured`);
+  }
+  const provider = config.providers.find((p) => p.id === found.providerId);
+  return { provider, model: found };
+}
+
+function maskSecret(value) {
+  if (!value || typeof value !== "string") return value;
+  if (value.length <= 8) return "***";
+  return `${value.slice(0, 3)}***${value.slice(-4)}`;
+}
+
+function redactConfig(config) {
+  return {
+    ...config,
+    providers: (config.providers || []).map((provider) => ({
+      ...provider,
+      apiKey: provider.apiKey ? maskSecret(provider.apiKey) : undefined,
+    })),
+  };
+}
+
+function bundledTemplatePath() {
+  return path.resolve(__dirname, "..", "config.example.json");
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  ensureConfigDir,
+  writeDefaultConfig,
+  loadConfig,
+  validateConfig,
+  resolveApiKey,
+  resolveModel,
+  listModels,
+  redactConfig,
+  bundledTemplatePath,
+};
+
+},
+"src/cursor-models.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const childProcess = require("child_process");
+
+const STORAGE_KEY = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
+
+function toCursorModel(model) {
+  const name = model.displayName;
+  const providerName = model.providerName || model.providerId || "BYOK";
+  const contextLimit = model.contextTokenLimit || 128000;
+  const tooltipMarkdown = `**${escapeMarkdown(name)}**<br />OpenAI-compatible BYOK model via ${escapeMarkdown(providerName)}.<br /><br />${contextLimit.toLocaleString()} context window`;
+  return {
+    name,
+    defaultOn: true,
+    parameterDefinitions: [],
+    variants: [
+      {
+        parameterValues: [],
+        displayName: name,
+        isMaxMode: false,
+        isDefaultMaxConfig: true,
+        isDefaultNonMaxConfig: true,
+        tooltipData: tooltip(tooltipMarkdown),
+        displayNameOutsidePicker: name,
+        variantStringRepresentation: `${name}[]`,
+        legacySlug: name,
+      },
+    ],
+    legacySlugs: [name],
+    idAliases: [name],
+    cloudAgentEffortModes: [],
+    supportsAgent: true,
+    degradationStatus: 0,
+    tooltipData: tooltip(tooltipMarkdown),
+    supportsThinking: false,
+    supportsImages: model.supportsImages !== false,
+    supportsMaxMode: true,
+    clientDisplayName: name,
+    serverModelName: name,
+    supportsNonMaxMode: true,
+    tooltipDataForMaxMode: tooltip(tooltipMarkdown),
+    isRecommendedForBackgroundComposer: false,
+    supportsPlanMode: true,
+    inputboxShortModelName: name,
+    supportsSandboxing: true,
+    supportsCmdK: true,
+    contextTokenLimit: contextLimit,
+    contextTokenLimitForMaxMode: contextLimit,
+    maxOutputTokens: model.maxOutputTokens || 8192,
+    namedModelSectionIndex: 1,
+    vendorName: providerName,
+    vendor: { id: 9000, displayName: providerName },
+    tagline: "OpenAI-compatible BYOK",
+    visibleInRoutedModelView: true,
+    isUserAdded: true,
+    byokModel: true,
+  };
+}
+
+function enrichCursorModels(existing, models) {
+  const out = Array.isArray(existing) ? existing.slice() : [];
+  for (const model of models || []) {
+    const cursorModel = toCursorModel(model);
+    const index = out.findIndex((item) => sameModel(item, cursorModel.name));
+    if (index >= 0) out[index] = { ...out[index], ...cursorModel };
+    else out.push(cursorModel);
+  }
+  return out;
+}
+
+function syncCursorStorage(models, options = {}) {
+  if (!Array.isArray(models) || models.length === 0) return { skipped: true, reason: "no models" };
+  const dbPath = options.dbPath || cursorStateDbPath();
+  if (!dbPath) return { skipped: true, reason: "unsupported platform" };
+  const sqlite = options.sqlite || "sqlite3";
+  let raw;
+  try {
+    raw = childProcess.execFileSync(sqlite, [dbPath, `select value from ItemTable where key=${sqlString(STORAGE_KEY)};`], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024,
+    });
+  } catch (err) {
+    return { skipped: true, reason: `storage unavailable: ${err.message}` };
+  }
+  if (!raw.trim()) return { skipped: true, reason: "storage key not initialized" };
+
+  const data = JSON.parse(raw);
+  const before = Array.isArray(data.availableDefaultModels2) ? data.availableDefaultModels2.length : 0;
+  data.availableDefaultModels2 = enrichCursorModels(data.availableDefaultModels2, models);
+  data.aiSettings = data.aiSettings || {};
+  data.aiSettings.modelOverrideDisabled = removeNames(data.aiSettings.modelOverrideDisabled, models);
+  data.aiSettings.modelOverrideEnabled = addNames(data.aiSettings.modelOverrideEnabled, models);
+
+  const value = JSON.stringify(data);
+  childProcess.execFileSync(sqlite, [
+    dbPath,
+    `update ItemTable set value=${sqlString(value)} where key=${sqlString(STORAGE_KEY)};`,
+  ], { stdio: ["ignore", "ignore", "pipe"], maxBuffer: 10 * 1024 * 1024 });
+  return { synced: true, dbPath, before, after: data.availableDefaultModels2.length };
+}
+
+function cursorStateDbPath() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  return null;
+}
+
+function addNames(values, models) {
+  const out = new Set(Array.isArray(values) ? values : []);
+  for (const model of models) out.add(model.displayName);
+  return Array.from(out);
+}
+
+function removeNames(values, models) {
+  if (!Array.isArray(values)) return [];
+  const names = new Set(models.map((model) => model.displayName));
+  return values.filter((value) => !names.has(value));
+}
+
+function sameModel(item, name) {
+  return item && (item.name === name || item.clientDisplayName === name || item.serverModelName === name);
+}
+
+function sqlString(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function tooltip(markdownContent) {
+  return {
+    primaryText: "",
+    secondaryText: "",
+    secondaryWarningText: false,
+    icon: "",
+    tertiaryText: "",
+    tertiaryTextUrl: "",
+    markdownContent,
+  };
+}
+
+function escapeMarkdown(value) {
+  return String(value == null ? "" : value).replace(/[\\*_[\]`]/g, "\\$&");
+}
+
+module.exports = {
+  STORAGE_KEY,
+  toCursorModel,
+  enrichCursorModels,
+  syncCursorStorage,
+  cursorStateDbPath,
+  sqlString,
+};
+
+},
+"src/logger.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const { ensureConfigDir } = require("./config");
+const { logPath } = require("./paths");
+
+function redactText(text) {
+  return String(text)
+    .replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***")
+    .replace(/Bearer\s+[A-Za-z0-9._-]{8,}/gi, "Bearer ***");
+}
+
+function log(event, meta) {
+  ensureConfigDir();
+  const suffix = meta === undefined ? "" : " " + redactText(JSON.stringify(meta));
+  fs.appendFileSync(logPath(), `[${new Date().toISOString()}] ${event}${suffix}\n`);
+}
+
+function tailLog(lines = 120) {
+  if (!fs.existsSync(logPath())) return "";
+  const data = fs.readFileSync(logPath(), "utf8");
+  return data.split(/\r?\n/).slice(-lines).join("\n");
+}
+
+module.exports = { log, tailLog, redactText };
+
+},
+"src/cli/service.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const childProcess = require("child_process");
+const {
+  pidPath,
+  logPath,
+  installedExtensionDir,
+  cursorExtensionsDir,
+  ensureDir,
+} = require("../paths");
+const { ensureConfigDir } = require("../config");
+
+function nodeBin() {
+  return process.execPath;
+}
+
+function daemonScript(baseDir = path.resolve(__dirname, "..")) {
+  const packageRoot = path.resolve(__dirname, "..", "..");
+  const bundled = path.join(packageRoot, "lib", "daemon-entry.js");
+  if (fs.existsSync(bundled)) return bundled;
+  return path.join(baseDir, "daemon-entry.js");
+}
+
+function isRunning() {
+  try {
+    const pid = Number(fs.readFileSync(pidPath(), "utf8"));
+    if (!pid) return false;
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return false;
+  }
+}
+
+function startForeground() {
+  require("../daemon-entry");
+}
+
+function startBackground() {
+  ensureConfigDir();
+  const existing = isRunning();
+  if (existing) return { alreadyRunning: true, pid: existing };
+  const out = fs.openSync(logPath(), "a");
+  const err = fs.openSync(logPath(), "a");
+  const child = childProcess.spawn(nodeBin(), [daemonScript()], {
+    detached: false,
+    stdio: ["ignore", out, err],
+    env: { ...process.env },
+  });
+  child.unref();
+  fs.writeFileSync(pidPath(), String(child.pid));
+  return { started: true, pid: child.pid };
+}
+
+function stopBackground() {
+  const pid = isRunning();
+  if (!pid) return { stopped: false };
+  process.kill(pid, "SIGTERM");
+  try { fs.unlinkSync(pidPath()); } catch {}
+  return { stopped: true, pid };
+}
+
+function installExtension() {
+  const sourceRoot = path.resolve(__dirname, "..", "..");
+  const target = installedExtensionDir();
+  ensureDir(cursorExtensionsDir());
+  removeInstalledExtensionVersions(target);
+  fs.rmSync(target, { recursive: true, force: true });
+  copyTree(sourceRoot, target, {
+    exclude: new Set(["dist", "test", ".git", ".DS_Store"]),
+  });
+  writeCursorExtensionIndex(target);
+  clearObsoleteMarker(path.basename(target));
+  return { installed: true, extensionDir: target };
+}
+
+function uninstallExtension() {
+  const target = installedExtensionDir();
+  removeInstalledExtensionVersions();
+  removeFromCursorExtensionIndex();
+  markObsolete(path.basename(target));
+  return { uninstalled: true, extensionDir: target };
+}
+
+function extensionStatus() {
+  const target = installedExtensionDir();
+  return { installed: fs.existsSync(path.join(target, "extension", "extension.js")), extensionDir: target };
+}
+
+function copyTree(src, dst, options = {}) {
+  const base = path.basename(src);
+  if (options.exclude && options.exclude.has(base)) return;
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dst, { recursive: true });
+    for (const entry of fs.readdirSync(src)) copyTree(path.join(src, entry), path.join(dst, entry), options);
+    return;
+  }
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+}
+
+function removeInstalledExtensionVersions(except) {
+  const dir = cursorExtensionsDir();
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.startsWith("cursor-openai-byok.cursor-openai-byok-")) continue;
+    const full = path.join(dir, entry);
+    if (except && full === except) continue;
+    fs.rmSync(full, { recursive: true, force: true });
+  }
+}
+
+function writeCursorExtensionIndex(target) {
+  const manifest = JSON.parse(fs.readFileSync(path.join(target, "package.json"), "utf8"));
+  const file = path.join(cursorExtensionsDir(), "extensions.json");
+  let entries = [];
+  try {
+    entries = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!Array.isArray(entries)) entries = [];
+  } catch {}
+  entries = entries.filter((entry) => entry?.identifier?.id !== "cursor-openai-byok.cursor-openai-byok");
+  entries.push({
+    identifier: { id: "cursor-openai-byok.cursor-openai-byok" },
+    version: manifest.version,
+    location: {
+      $mid: 1,
+      fsPath: target,
+      external: `file://${target}`,
+      path: target,
+      scheme: "file",
+    },
+    relativeLocation: path.basename(target),
+  });
+  fs.writeFileSync(file, JSON.stringify(entries, null, 2));
+}
+
+function removeFromCursorExtensionIndex() {
+  const file = path.join(cursorExtensionsDir(), "extensions.json");
+  let entries = [];
+  try {
+    entries = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!Array.isArray(entries)) entries = [];
+  } catch {}
+  entries = entries.filter((entry) => entry?.identifier?.id !== "cursor-openai-byok.cursor-openai-byok");
+  fs.writeFileSync(file, JSON.stringify(entries, null, 2));
+}
+
+function readObsolete() {
+  const file = path.join(cursorExtensionsDir(), ".obsolete");
+  try {
+    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeObsolete(value) {
+  fs.writeFileSync(path.join(cursorExtensionsDir(), ".obsolete"), JSON.stringify(value));
+}
+
+function clearObsoleteMarker(relativeLocation) {
+  const obsolete = readObsolete();
+  delete obsolete[relativeLocation];
+  writeObsolete(obsolete);
+}
+
+function markObsolete(relativeLocation) {
+  const obsolete = readObsolete();
+  obsolete[relativeLocation] = true;
+  writeObsolete(obsolete);
+}
+
+module.exports = {
+  isRunning,
+  startForeground,
+  startBackground,
+  stopBackground,
+  installExtension,
+  uninstallExtension,
+  extensionStatus,
+};
+
+},
+"src/daemon-entry.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const { startServer } = require("./daemon/server");
+const { pidPath } = require("./paths");
+const fs = require("fs");
+
+fs.writeFileSync(pidPath(), String(process.pid));
+const server = startServer();
+
+function shutdown() {
+  try { fs.unlinkSync(pidPath()); } catch {}
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 1000).unref();
+}
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+process.on("exit", () => {
+  try { fs.unlinkSync(pidPath()); } catch {}
+});
+
+},
+"src/daemon/server.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const http = require("http");
+const { loadConfig, listModels, resolveModel } = require("../config");
+const { log } = require("../logger");
+const { DEFAULT_PORT } = require("../paths");
+const { cursorPayloadToOpenAI } = require("../cursor-agent-adapter/messages");
+const {
+  proxyOpenAIRequest,
+  streamProviderEvents,
+  callProviderOnce,
+} = require("../provider-adapters/openai-compatible");
+
+function readJson(req, limit = 30 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > limit) {
+        reject(new Error("request too large"));
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJson(res, status, body) {
+  res.writeHead(status, corsHeaders({ "content-type": "application/json; charset=utf-8" }));
+  res.end(JSON.stringify(body));
+}
+
+function corsHeaders(extra = {}) {
+  return {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "content-type,authorization,openai-beta",
+    ...extra,
+  };
+}
+
+async function pipeProviderResponse(res, providerResponse) {
+  const headers = {
+    "content-type": providerResponse.headers.get("content-type") || "application/json; charset=utf-8",
+  };
+  res.writeHead(providerResponse.status, corsHeaders(headers));
+  if (!providerResponse.body) {
+    res.end(await providerResponse.text());
+    return;
+  }
+  for await (const chunk of providerResponse.body) res.write(chunk);
+  res.end();
+}
+
+async function sendNdjson(res, iterator) {
+  res.writeHead(200, corsHeaders({ "content-type": "application/x-ndjson; charset=utf-8" }));
+  try {
+    for await (const event of iterator) {
+      res.write(JSON.stringify(event) + "\n");
+    }
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    log("stream-error", { error: err && err.stack ? err.stack : message });
+    res.write(JSON.stringify({ type: "error", error: message }) + "\n");
+  }
+  res.write(JSON.stringify({ type: "done" }) + "\n");
+  res.end();
+}
+
+async function* runCursorAgentLoop(config, payload) {
+  const requestedModel = payload.model || payload.modelName || payload?.runRequest?.requestedModel?.modelId;
+  const route = resolveModel(config, requestedModel);
+  const openaiBody = cursorPayloadToOpenAI(payload, route);
+  log("cursor-run", {
+    model: route.model.displayName,
+    provider: route.provider.id,
+    conversationId: payload.conversationId,
+    generationUUID: payload.generationUUID,
+  });
+
+  if (route.model.supportsStreaming === false) {
+    const text = await callProviderOnce(config, route, openaiBody);
+    if (text) yield { type: "text_delta", text };
+    return;
+  }
+
+  const pendingTools = new Map();
+  for await (const event of streamProviderEvents(config, route, openaiBody)) {
+    if (event.type === "tool_call_delta") {
+      const key = event.id || String(event.index || pendingTools.size);
+      const existing = pendingTools.get(key) || { id: key, name: event.name, arguments: "" };
+      existing.name = event.name || existing.name;
+      existing.arguments += event.argumentsDelta || "";
+      pendingTools.set(key, existing);
+      yield event;
+      continue;
+    }
+    if (event.type === "tool_call") {
+      pendingTools.set(event.id, event);
+      yield event;
+      continue;
+    }
+    if (event.type === "finish" && pendingTools.size > 0) {
+      yield { type: "tool_calls_ready", toolCalls: [...pendingTools.values()] };
+      pendingTools.clear();
+      return;
+    }
+    yield event;
+  }
+}
+
+function createServer() {
+  return http.createServer(async (req, res) => {
+    try {
+      if (req.method === "OPTIONS") return sendJson(res, 204, {});
+      const config = loadConfig();
+      const url = new URL(req.url, "http://127.0.0.1");
+
+      if (req.method === "GET" && url.pathname === "/health") {
+        return sendJson(res, 200, {
+          ok: true,
+          app: "cursor-openai-byok",
+          models: listModels(config).map((m) => m.displayName),
+        });
+      }
+
+      if (req.method === "GET" && url.pathname === "/cursor/v1/models") {
+        return sendJson(res, 200, { ok: true, models: listModels(config) });
+      }
+
+      if (req.method === "GET" && url.pathname === "/cursor/v1/should-handle") {
+        const model = url.searchParams.get("model");
+        try {
+          const route = resolveModel(config, model);
+          return sendJson(res, 200, { ok: true, handle: true, model: route.model });
+        } catch {
+          return sendJson(res, 200, { ok: true, handle: false });
+        }
+      }
+
+      if (req.method === "POST" && url.pathname === "/cursor/v1/run-agent-loop") {
+        const payload = await readJson(req);
+        return sendNdjson(res, runCursorAgentLoop(config, payload));
+      }
+
+      if (req.method === "POST" && url.pathname === "/cursor/v1/tool-result") {
+        const payload = await readJson(req);
+        log("tool-result", {
+          conversationId: payload.conversationId,
+          callId: payload.callId,
+          ok: payload.ok !== false,
+        });
+        return sendJson(res, 200, { ok: true });
+      }
+
+      if (req.method === "POST" && url.pathname === "/v1/responses") {
+        const body = await readJson(req);
+        return pipeProviderResponse(res, await proxyOpenAIRequest(config, "responses", body, req.headers));
+      }
+
+      if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+        const body = await readJson(req);
+        return pipeProviderResponse(res, await proxyOpenAIRequest(config, "chat", body, req.headers));
+      }
+
+      sendJson(res, 404, { ok: false, error: "not found" });
+    } catch (err) {
+      log("error", { url: req.url, error: err && err.stack ? err.stack : String(err) });
+      sendJson(res, 500, { ok: false, error: err && err.message ? err.message : String(err) });
+    }
+  });
+}
+
+function startServer(options = {}) {
+  const config = loadConfig();
+  const host = options.host || config.server?.host || "127.0.0.1";
+  const port = Number(options.port || config.server?.port || DEFAULT_PORT);
+  const server = createServer();
+  server.listen(port, host, () => {
+    log("listening", { host, port });
+    console.log(`cursor-openai-byok listening on http://${host}:${port}`);
+  });
+  return server;
+}
+
+module.exports = { createServer, startServer, runCursorAgentLoop, readJson };
+
+},
+"src/cursor-agent-adapter/messages.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
+const IMAGE_MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+
+function looksLikeNoise(key, value) {
+  const k = String(key || "").toLowerCase();
+  if (k.includes("id") || k.includes("uuid") || k.includes("path") || k.includes("url")) return true;
+  if (k.includes("model") || k.includes("token") || k.includes("hash")) return true;
+  if (/^[a-z0-9_-]{24,}$/i.test(value) && !value.includes(" ")) return true;
+  return value.length > 120000;
+}
+
+function collectStrings(value, out = [], pathParts = []) {
+  if (value == null) return out;
+  if (typeof value === "string") {
+    const key = pathParts[pathParts.length - 1] || "";
+    const text = value.trim();
+    if (text && !looksLikeNoise(key, text)) {
+      const lower = String(key).toLowerCase();
+      let score = 1;
+      if (["text", "content", "prompt", "userMessage", "message", "instruction", "instructions", "query"].includes(key)) score += 20;
+      if (lower.includes("text") || lower.includes("content") || lower.includes("prompt") || lower.includes("message")) score += 10;
+      if (/[\u4e00-\u9fff]/.test(text)) score += 2;
+      out.push({ text, score, path: pathParts.join(".") });
+    }
+    return out;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => collectStrings(item, out, pathParts.concat(String(i))));
+    return out;
+  }
+  if (typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) collectStrings(child, out, pathParts.concat(key));
+  }
+  return out;
+}
+
+function extractUserText(payload) {
+  const direct =
+    payload?.userText ||
+    payload?.text ||
+    payload?.runRequest?.action?.userMessageAction?.userMessage?.text ||
+    payload?.runRequest?.action?.userMessageAction?.prependUserMessages?.at?.(-1)?.text;
+  if (typeof direct === "string" && direct.trim()) return direct.trim();
+  const candidates = collectStrings(payload)
+    .filter((candidate) => candidate.text.length <= 20000)
+    .sort((a, b) => a.score - b.score);
+  const chosen = candidates[candidates.length - 1];
+  return chosen ? chosen.text : "";
+}
+
+function parseJsonMaybe(value) {
+  if (value == null) return undefined;
+  if (typeof value === "object") return value;
+  if (typeof value !== "string") return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function extractConversationMessages(payload) {
+  const messages = [];
+  const turns = payload?.runRequest?.conversationState?.turns || payload?.conversationState?.turns || [];
+  for (const turn of turns) {
+    const parsed = parseJsonMaybe(turn);
+    const text = extractUserText(parsed || turn);
+    if (text) messages.push({ role: "user", content: text });
+  }
+  const current = extractUserText(payload);
+  const images = extractImages(payload);
+  if (current || images.length > 0) messages.push({ role: "user", content: current, images });
+  if (messages.length === 0) messages.push({ role: "user", content: "Please reply briefly." });
+  return compactMessages(messages);
+}
+
+function compactMessages(messages) {
+  const out = [];
+  for (const message of messages) {
+    if (!message.content && !message.images?.length) continue;
+    const prev = out[out.length - 1];
+    if (prev && prev.role === message.role && prev.content === message.content) continue;
+    const images = Array.isArray(message.images) && message.images.length > 0 ? message.images : undefined;
+    out.push({
+      role: message.role,
+      content: message.content || "",
+      ...(images ? { images } : {}),
+    });
+  }
+  return out.slice(-32);
+}
+
+function toResponsesInput(messages) {
+  return messages.map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: toResponsesContent(message),
+  }));
+}
+
+function toChatMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: toChatContent(message),
+  }));
+}
+
+function toResponsesContent(message) {
+  const content = [];
+  const text = String(message.content || "");
+  if (text || !message.images?.length) {
+    content.push({
+      type: message.role === "assistant" ? "output_text" : "input_text",
+      text,
+    });
+  }
+  if (message.role !== "assistant") {
+    for (const image of message.images || []) {
+      content.push({ type: "input_image", image_url: image.url });
+    }
+  }
+  return content;
+}
+
+function toChatContent(message) {
+  if (message.role === "assistant" || !message.images?.length) return String(message.content || "");
+  const content = [];
+  const text = String(message.content || "");
+  if (text) content.push({ type: "text", text });
+  for (const image of message.images) content.push({ type: "image_url", image_url: { url: image.url } });
+  return content;
+}
+
+function cursorPayloadToOpenAI(payload, route) {
+  const messages = extractConversationMessages(payload);
+  const max = route.model.maxOutputTokens;
+  if (route.provider.type === "openai-responses") {
+    return {
+      model: route.model.apiModel,
+      stream: true,
+      input: toResponsesInput(messages),
+      tools: normalizeTools(payload?.tools || payload?.runRequest?.mcpTools),
+      tool_choice: payload?.tool_choice || "auto",
+      parallel_tool_calls: payload?.parallel_tool_calls !== false,
+      max_output_tokens: payload?.max_output_tokens || max,
+    };
+  }
+  return {
+    model: route.model.apiModel,
+    stream: true,
+    messages: toChatMessages(messages),
+    tools: normalizeTools(payload?.tools || payload?.runRequest?.mcpTools),
+    tool_choice: payload?.tool_choice || "auto",
+    parallel_tool_calls: payload?.parallel_tool_calls !== false,
+    max_tokens: payload?.max_tokens || payload?.max_output_tokens || max,
+  };
+}
+
+function normalizeTools(tools) {
+  if (!tools) return undefined;
+  if (Array.isArray(tools)) return tools;
+  const values = Object.values(tools);
+  if (values.length === 0) return undefined;
+  return values;
+}
+
+function extractImages(payload) {
+  const images = [];
+  const seen = new Set();
+  collectImages(payload, images, seen, []);
+  return images.slice(0, 8);
+}
+
+function collectImages(value, out, seen, pathParts) {
+  if (value == null || out.length >= 8) return;
+  if (typeof value === "string") {
+    const image = imageFromString(value, pathParts);
+    if (image && !seen.has(image.url)) {
+      seen.add(image.url);
+      out.push(image);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectImages(item, out, seen, pathParts.concat(String(index))));
+    return;
+  }
+  if (typeof value !== "object") return;
+
+  const direct = imageFromObject(value, pathParts);
+  if (direct && !seen.has(direct.url)) {
+    seen.add(direct.url);
+    out.push(direct);
+  }
+  for (const [key, child] of Object.entries(value)) collectImages(child, out, seen, pathParts.concat(key));
+}
+
+function imageFromObject(value, pathParts) {
+  const mime = value.mimeType || value.mimetype || value.contentType || value.type;
+  if (typeof mime === "string" && mime.startsWith("image/")) {
+    const data = value.data || value.base64 || value.bytes || value.content;
+    if (typeof data === "string") {
+      if (data.startsWith("data:image/")) return { url: data, source: pathParts.join(".") };
+      if (looksLikeImageBase64(data)) return { url: `data:${mime};base64,${stripBase64(data)}`, source: pathParts.join(".") };
+    }
+  }
+  const file = value.path || value.filePath || value.fsPath || value.uri;
+  if (typeof file === "string") return imageFromString(file, pathParts);
+  const url = value.url || value.imageUrl || value.image_url;
+  if (typeof url === "string") return imageFromString(url, pathParts);
+  return null;
+}
+
+function imageFromString(value, pathParts = []) {
+  const text = value.trim();
+  if (!text) return null;
+  if (/^data:image\/[a-z0-9.+-]+;base64,/i.test(text)) return { url: text, source: pathParts.join(".") };
+  if (/^https?:\/\//i.test(text) && looksLikeImagePath(text)) return { url: text, source: pathParts.join(".") };
+  if (text.startsWith("file://")) return imageFromFilePath(decodeURIComponent(new URL(text).pathname), pathParts);
+  if (looksLikeImagePath(text)) return imageFromFilePath(text, pathParts);
+  if (pathParts.some((part) => /image|base64|bytes|data/i.test(part)) && looksLikeImageBase64(text)) {
+    const mime = mimeFromImageBase64(text);
+    if (mime) return { url: `data:${mime};base64,${stripBase64(text)}`, source: pathParts.join(".") };
+  }
+  return null;
+}
+
+function imageFromFilePath(file, pathParts) {
+  try {
+    const resolved = path.resolve(String(file).replace(/^~(?=\/|\\)/, process.env.HOME || ""));
+    if (!looksLikeImagePath(resolved)) return null;
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile() || stat.size > MAX_IMAGE_BYTES) return null;
+    const ext = path.extname(resolved).toLowerCase();
+    const mime = IMAGE_MIME_BY_EXT[ext] || "image/png";
+    return { url: `data:${mime};base64,${fs.readFileSync(resolved).toString("base64")}`, source: pathParts.join(".") };
+  } catch {
+    return null;
+  }
+}
+
+function looksLikeImagePath(value) {
+  try {
+    const clean = String(value).split(/[?#]/)[0];
+    return IMAGE_EXTENSIONS.has(path.extname(clean).toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+function looksLikeImageBase64(value) {
+  const stripped = stripBase64(value);
+  if (stripped.length < 32 || stripped.length > MAX_IMAGE_BYTES * 2) return false;
+  return !!mimeFromImageBase64(stripped);
+}
+
+function mimeFromImageBase64(value) {
+  const stripped = stripBase64(value);
+  if (stripped.startsWith("iVBORw0KGgo")) return "image/png";
+  if (stripped.startsWith("/9j/")) return "image/jpeg";
+  if (stripped.startsWith("UklGR")) return "image/webp";
+  if (stripped.startsWith("R0lGOD")) return "image/gif";
+  return null;
+}
+
+function stripBase64(value) {
+  return String(value).replace(/^data:image\/[a-z0-9.+-]+;base64,/i, "").replace(/\s+/g, "");
+}
+
+module.exports = {
+  extractUserText,
+  extractConversationMessages,
+  extractImages,
+  cursorPayloadToOpenAI,
+  toResponsesInput,
+  toChatMessages,
+};
+
+},
+"src/provider-adapters/openai-compatible.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const { resolveApiKey, resolveModel } = require("../config");
+
+function endpointFor(provider, kind) {
+  const base = provider.baseUrl.replace(/\/+$/, "");
+  if (kind === "responses") return `${base}/responses`;
+  if (kind === "chat") return `${base}/chat/completions`;
+  throw new Error(`Unknown endpoint kind ${kind}`);
+}
+
+function routeRequestModel(config, body, preferredKind) {
+  const route = resolveModel(config, body && body.model);
+  const kind = preferredKind || (route.provider.type === "openai-responses" ? "responses" : "chat");
+  const mapped = { ...(body || {}), model: route.model.apiModel };
+  return { ...route, body: mapped, kind };
+}
+
+async function proxyOpenAIRequest(config, kind, body, headers = {}) {
+  const route = routeRequestModel(config, body, kind);
+  return fetchProviderWithUnsupportedParamRetry(route.provider, route.kind, route.body, headers);
+}
+
+function outboundHeaders(provider, incoming = {}) {
+  const headers = {
+    "content-type": "application/json",
+    authorization: `Bearer ${resolveApiKey(provider)}`,
+  };
+  for (const [key, value] of Object.entries(incoming || {})) {
+    const lower = key.toLowerCase();
+    if (lower.startsWith("x-") || lower === "openai-beta") headers[key] = value;
+  }
+  return headers;
+}
+
+async function* streamProviderEvents(config, route, openaiBody) {
+  const kind = route.provider.type === "openai-responses" ? "responses" : "chat";
+  const body = {
+    ...openaiBody,
+    model: route.model.apiModel,
+    stream: true,
+  };
+  const res = await fetchProviderWithUnsupportedParamRetry(route.provider, kind, body);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Provider ${res.status}: ${text.slice(0, 1200)}`);
+  }
+  if (!res.body) throw new Error("Provider response is not streamable");
+  for await (const event of parseSse(res.body)) {
+    if (event === "[DONE]") break;
+    let json;
+    try {
+      json = JSON.parse(event);
+    } catch {
+      continue;
+    }
+    yield* normalizeProviderEvent(kind, json);
+  }
+}
+
+async function callProviderOnce(config, route, openaiBody) {
+  const kind = route.provider.type === "openai-responses" ? "responses" : "chat";
+  const body = { ...openaiBody, model: route.model.apiModel, stream: false };
+  const res = await fetchProviderWithUnsupportedParamRetry(route.provider, kind, body);
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Provider returned non-JSON ${res.status}: ${text.slice(0, 500)}`);
+  }
+  if (!res.ok) throw new Error(`Provider ${res.status}: ${JSON.stringify(json).slice(0, 1200)}`);
+  return extractFinalText(kind, json);
+}
+
+async function fetchProviderWithUnsupportedParamRetry(provider, kind, body, headers = {}) {
+  const attempted = new Set();
+  let current = sanitizeBodyForProvider(provider, body);
+  for (;;) {
+    const res = await fetch(endpointFor(provider, kind), {
+      method: "POST",
+      headers: outboundHeaders(provider, headers),
+      body: JSON.stringify(current),
+    });
+    if (res.ok) return res;
+
+    const text = await res.text();
+    const unsupported = parseUnsupportedParameter(text);
+    if (!unsupported || attempted.has(unsupported) || !Object.prototype.hasOwnProperty.call(current, unsupported)) {
+      return responseFromText(text, res);
+    }
+    attempted.add(unsupported);
+    current = { ...current };
+    delete current[unsupported];
+  }
+}
+
+function sanitizeBodyForProvider(provider, body) {
+  const out = { ...(body || {}) };
+  for (const param of provider.omitParams || provider.unsupportedParams || []) {
+    delete out[param];
+  }
+  return out;
+}
+
+function parseUnsupportedParameter(text) {
+  if (!text) return null;
+  try {
+    const json = JSON.parse(text);
+    const message = json?.error?.message || json?.message || "";
+    const param = json?.error?.param || json?.param || "";
+    if (param && /unsupported parameter/i.test(message)) return param;
+    const fromMessage = message.match(/Unsupported parameter:\s*['"]?([A-Za-z0-9_.-]+)['"]?/i);
+    if (fromMessage) return fromMessage[1];
+  } catch {}
+  const match = String(text).match(/Unsupported parameter:\s*['"]?([A-Za-z0-9_.-]+)['"]?/i);
+  return match ? match[1] : null;
+}
+
+function responseFromText(text, res) {
+  return new Response(text, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries()),
+  });
+}
+
+async function* parseSse(body) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf("\n\n")) >= 0) {
+      const raw = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      const data = raw
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+      if (data) yield data;
+    }
+  }
+  buffer += decoder.decode();
+  const data = buffer
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trimStart())
+    .join("\n");
+  if (data) yield data;
+}
+
+function* normalizeProviderEvent(kind, event) {
+  if (kind === "chat") {
+    const choice = event.choices && event.choices[0];
+    const delta = choice && choice.delta;
+    if (delta && typeof delta.content === "string" && delta.content) {
+      yield { type: "text_delta", text: delta.content };
+    }
+    for (const toolCall of delta?.tool_calls || []) {
+      yield {
+        type: "tool_call_delta",
+        id: toolCall.id,
+        index: toolCall.index,
+        name: toolCall.function && toolCall.function.name,
+        argumentsDelta: toolCall.function && toolCall.function.arguments,
+      };
+    }
+    if (choice && choice.finish_reason) yield { type: "finish", reason: choice.finish_reason };
+    return;
+  }
+
+  if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
+    yield { type: "text_delta", text: event.delta };
+    return;
+  }
+  if (event.type === "response.function_call_arguments.delta") {
+    yield {
+      type: "tool_call_delta",
+      id: event.item_id,
+      name: event.name,
+      argumentsDelta: event.delta || "",
+    };
+    return;
+  }
+  if (event.type === "response.output_item.done" && event.item && event.item.type === "function_call") {
+    yield {
+      type: "tool_call",
+      id: event.item.call_id || event.item.id,
+      name: event.item.name,
+      arguments: event.item.arguments || "{}",
+    };
+    return;
+  }
+  if (event.type === "response.completed") yield { type: "finish", reason: "completed" };
+}
+
+function extractFinalText(kind, response) {
+  if (kind === "chat") {
+    return response?.choices?.[0]?.message?.content || "";
+  }
+  if (typeof response.output_text === "string") return response.output_text;
+  const parts = [];
+  for (const item of response.output || []) {
+    for (const content of item.content || []) {
+      if (typeof content.text === "string") parts.push(content.text);
+    }
+  }
+  return parts.join("");
+}
+
+module.exports = {
+  endpointFor,
+  routeRequestModel,
+  proxyOpenAIRequest,
+  streamProviderEvents,
+  callProviderOnce,
+  parseSse,
+  normalizeProviderEvent,
+  extractFinalText,
+  fetchProviderWithUnsupportedParamRetry,
+  parseUnsupportedParameter,
+  sanitizeBodyForProvider,
+};
+
+},
+"src/patcher/index.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { findCursorAppRoot, readCursorInfo } = require("./cursor-paths");
+const { MARKER, LEGACY_MARKER, helperSnippet, agentLoopSnippet } = require("./templates");
+
+const RUN_LOOP_NEEDLE = `_e=SC(n.withName("AgentCompatService.agentClientService.run")),oe=new Q$t(this.instantiationService,z,re,f,ue);`;
+const CONNECT_HELPER_NEEDLE = `function E5_(n,e){return vp1(n,t=>{switch(t.kind){case rn.Unary:return wp1(e,n,t);case rn.ServerStreaming:return Sp1(e,n,t);case rn.ClientStreaming:return kp1(e,n,t);case rn.BiDiStreaming:return Cp1(e,n,t);default:return null}})}`;
+const UNARY_NEEDLE = `const s=await n.unary(e,t,r?.signal,r?.timeoutMs,r?.headers,i,r?.contextValues);return r?.onHeader?.(s.header),r?.onTrailer?.(s.trailer),s.message`;
+const MODEL_ENRICH_NEEDLE = `s=XI_(s,a.models);`;
+
+function status(options = {}) {
+  const appRoot = findCursorAppRoot(options.appRoot);
+  const info = readCursorInfo(appRoot);
+  const source = fs.readFileSync(info.workbenchPath, "utf8");
+  return {
+    ...info,
+    supportedVersion: isSupportedVersion(info.version),
+    patched: source.includes(MARKER),
+    legacyPatched: source.includes(LEGACY_MARKER),
+    hasRunLoopNeedle: !!findRunLoopPatchPoint(source),
+    hasConnectNeedle: !!findConnectHelperNeedle(source),
+    hasModelEnrichNeedle: source.includes(MODEL_ENRICH_NEEDLE),
+  };
+}
+
+function installPatch(options = {}) {
+  const appRoot = findCursorAppRoot(options.appRoot);
+  const info = readCursorInfo(appRoot);
+  if (!isSupportedVersion(info.version) && !options.force) {
+    throw new Error(`Unsupported Cursor version ${info.version}. Re-run with --force only after validating needles.`);
+  }
+  let source = fs.readFileSync(info.workbenchPath, "utf8");
+  if (source.includes(MARKER)) return { ...info, changed: false, alreadyInstalled: true };
+  if (source.includes(LEGACY_MARKER) && !options.force) {
+    throw new Error("Legacy local BYOK patch is already present. Restore Cursor from backup or use --force after manual review.");
+  }
+  const connectNeedle = findConnectHelperNeedle(source);
+  const runLoop = findRunLoopPatchPoint(source);
+  if (!runLoop) throw new Error("AgentCompatService.runAgentLoop needle not found");
+  if (!connectNeedle) throw new Error("Connect helper needle not found");
+  if (!source.includes(UNARY_NEEDLE)) throw new Error("Unary transport needle not found");
+  if (!source.includes(MODEL_ENRICH_NEEDLE)) throw new Error("Model enrichment needle not found");
+
+  const backupPath = backupWorkbench(info.workbenchPath);
+  source = source.replace(connectNeedle, helperSnippet() + connectNeedle);
+  source = source.replace(
+    UNARY_NEEDLE,
+    `const s=await n.unary(e,t,r?.signal,r?.timeoutMs,r?.headers,i,r?.contextValues);try{if(e?.typeName==="aiserver.v1.AiService"&&t?.name==="AvailableModels")await ${MARKER}().patchAvailableModels(s.message)}catch{}return r?.onHeader?.(s.header),r?.onTrailer?.(s.trailer),s.message`
+  );
+  source = source.replace(MODEL_ENRICH_NEEDLE, `s=XI_(s,a.models);s=await ${MARKER}().enrichModels(s);`);
+  source = source.replace(runLoop.needle, runLoop.needle + agentLoopSnippet(runLoop.vars));
+  fs.writeFileSync(info.workbenchPath, source);
+  return { ...info, changed: true, backupPath };
+}
+
+function uninstallPatch(options = {}) {
+  const appRoot = findCursorAppRoot(options.appRoot);
+  const info = readCursorInfo(appRoot);
+  const backups = findBackups(info.workbenchPath).filter((file) => {
+    const data = fs.readFileSync(file, "utf8");
+    return !data.includes(MARKER);
+  });
+  if (backups.length === 0) throw new Error("No suitable cursor-openai-byok backup found");
+  const latest = backups[backups.length - 1];
+  const currentBackup = backupWorkbench(info.workbenchPath, "pre-uninstall");
+  fs.copyFileSync(latest, info.workbenchPath);
+  return { ...info, restoredFrom: latest, currentBackup };
+}
+
+function backupWorkbench(workbenchPath, label = "backup") {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backup = `${workbenchPath}.${label}-cursor-openai-byok-${stamp}`;
+  fs.copyFileSync(workbenchPath, backup);
+  return backup;
+}
+
+function findBackups(workbenchPath) {
+  const dir = path.dirname(workbenchPath);
+  const base = path.basename(workbenchPath);
+  return fs.readdirSync(dir)
+    .filter((name) => name.startsWith(`${base}.backup-cursor-openai-byok-`) || name.includes("cursor-openai-byok"))
+    .map((name) => path.join(dir, name))
+    .sort();
+}
+
+function isSupportedVersion(version) {
+  return /^3\.8\./.test(version);
+}
+
+function findConnectHelperNeedle(source) {
+  if (source.includes(CONNECT_HELPER_NEEDLE)) return CONNECT_HELPER_NEEDLE;
+  const match = source.match(/function\s+\w+\(n,e\)\{return\s+\w+\(n,t=>\{switch\(t\.kind\)\{case\s+\w+\.Unary:return\s+\w+\(e,n,t\);case\s+\w+\.ServerStreaming:return\s+\w+\(e,n,t\);case\s+\w+\.ClientStreaming:return\s+\w+\(e,n,t\);case\s+\w+\.BiDiStreaming:return\s+\w+\(e,n,t\);default:return null\}\}\)\}/);
+  return match ? match[0] : null;
+}
+
+function findRunLoopPatchPoint(source) {
+  if (source.includes(RUN_LOOP_NEEDLE)) {
+    return {
+      needle: RUN_LOOP_NEEDLE,
+      vars: undefined,
+    };
+  }
+  const re = /const\{userText:(\w+),richText:(\w+),mode:(\w+),selectedContext:(\w+),requestContext:(\w+),modelDetails:(\w+),generationUUID:(\w+),conversationId:(\w+),messageId:(\w+),[\s\S]{0,900}?conversationState:(\w+),[\s\S]{0,1600}?(\w+)=_b\(n\.withName\("AgentCompatService\.agentClientService\.run"\)\),(\w+)=new\s+\w+\(this\.instantiationService,[^;]+?\);/;
+  const match = source.match(re);
+  if (!match) return null;
+  return {
+    needle: match[0],
+    vars: {
+      userText: match[1],
+      richText: match[2],
+      mode: match[3],
+      selectedContext: match[4],
+      requestContext: match[5],
+      model: match[6],
+      generationUUID: match[7],
+      conversationId: match[8],
+      messageId: match[9],
+      conversationState: match[10],
+      ctx: match[11],
+      adapter: match[12],
+      event: "e",
+    },
+  };
+}
+
+module.exports = { status, installPatch, uninstallPatch };
+
+},
+"src/patcher/cursor-paths.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function candidateCursorAppRoots() {
+  if (process.platform === "darwin") {
+    return [
+      "/Applications/Cursor.app/Contents/Resources/app",
+      path.join(os.homedir(), "Applications/Cursor.app/Contents/Resources/app"),
+    ];
+  }
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return [
+      path.join(local, "Programs", "Cursor", "resources", "app"),
+      path.join(local, "Cursor", "resources", "app"),
+    ];
+  }
+  return [];
+}
+
+function findCursorAppRoot(explicitRoot) {
+  const roots = explicitRoot ? [explicitRoot] : candidateCursorAppRoots();
+  for (const root of roots) {
+    const workbench = workbenchPath(root);
+    if (fs.existsSync(workbench)) return root;
+  }
+  throw new Error(`Cursor app root not found. Checked: ${roots.join(", ")}`);
+}
+
+function workbenchPath(appRoot) {
+  return path.join(appRoot, "out", "vs", "workbench", "workbench.desktop.main.js");
+}
+
+function productJsonPath(appRoot) {
+  return path.join(appRoot, "product.json");
+}
+
+function packageJsonPath(appRoot) {
+  return path.join(appRoot, "package.json");
+}
+
+function readCursorInfo(appRoot) {
+  const productPath = productJsonPath(appRoot);
+  const packagePath = packageJsonPath(appRoot);
+  const product = fs.existsSync(productPath) ? JSON.parse(fs.readFileSync(productPath, "utf8")) : {};
+  const pkg = fs.existsSync(packagePath) ? JSON.parse(fs.readFileSync(packagePath, "utf8")) : {};
+  return {
+    appRoot,
+    version: product.version || pkg.version || "unknown",
+    commit: product.commit || "unknown",
+    workbenchPath: workbenchPath(appRoot),
+  };
+}
+
+module.exports = {
+  candidateCursorAppRoots,
+  findCursorAppRoot,
+  workbenchPath,
+  readCursorInfo,
+};
+
+},
+"src/patcher/templates.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const MARKER = "__CURSOR_OPENAI_BYOK_V1";
+const LEGACY_MARKER = "__LOCAL_CURSOR_BYOK_V0";
+const ENDPOINT = "http://127.0.0.1:39832";
+
+function helperSnippet() {
+  return `function ${MARKER}(){if(globalThis.${MARKER})return globalThis.${MARKER};const endpoint="${ENDPOINT}";const sleep=ms=>new Promise(r=>setTimeout(r,ms));const tip=t=>({primaryText:"",secondaryText:"",secondaryWarningText:false,icon:"",tertiaryText:"",tertiaryTextUrl:"",markdownContent:t});const esc=v=>String(v??"").replace(/[\\\\*_\\[\\]\`]/g,"\\\\$&");const byok={async models(){const started=Date.now();for(;;){try{const r=await fetch(endpoint+"/cursor/v1/models");const j=await r.json();return j&&j.ok?j.models||[]:[]}catch(e){if(Date.now()-started>2e3)return[];await sleep(120)}}},toCursorModel(m){const name=m.displayName,provider=m.providerName||m.providerId||"BYOK",ctx=m.contextTokenLimit||128000,md="**"+esc(name)+"**<br />OpenAI-compatible BYOK model via "+esc(provider)+".<br /><br />"+ctx.toLocaleString()+" context window";return{name,defaultOn:true,parameterDefinitions:[],variants:[{parameterValues:[],displayName:name,isMaxMode:false,isDefaultMaxConfig:true,isDefaultNonMaxConfig:true,tooltipData:tip(md),displayNameOutsidePicker:name,variantStringRepresentation:name+"[]",legacySlug:name}],legacySlugs:[name],idAliases:[name],cloudAgentEffortModes:[],supportsAgent:true,degradationStatus:0,tooltipData:tip(md),supportsThinking:false,supportsImages:m.supportsImages!==false,supportsMaxMode:true,clientDisplayName:name,serverModelName:name,supportsNonMaxMode:true,tooltipDataForMaxMode:tip(md),isRecommendedForBackgroundComposer:false,supportsPlanMode:true,inputboxShortModelName:name,supportsSandboxing:true,supportsCmdK:true,contextTokenLimit:ctx,contextTokenLimitForMaxMode:ctx,maxOutputTokens:m.maxOutputTokens||8192,namedModelSectionIndex:1,vendorName:provider,vendor:{id:9000,displayName:provider},tagline:"OpenAI-compatible BYOK",visibleInRoutedModelView:true,isUserAdded:true,byokModel:true}},async shouldHandle(model){try{if(!model)return false;const r=await fetch(endpoint+"/cursor/v1/should-handle?model="+encodeURIComponent(model));const j=await r.json();return !!(j&&j.ok&&j.handle)}catch{return false}},async enrichModels(list){try{const models=await this.models();if(!models.length)return list;const out=Array.isArray(list)?list:[];for(const m of models){const cm=this.toCursorModel(m),i=out.findIndex(x=>x&&(x.name===m.displayName||x.clientDisplayName===m.displayName||x.serverModelName===m.displayName));i>=0?out[i]={...out[i],...cm}:out.push(cm)}return out}catch(e){console.warn("cursor-openai-byok model enrich failed",e);return list}},async patchAvailableModels(msg){try{const models=await this.models();if(!models.length||!msg)return;msg.modelNames=msg.modelNames||[];msg.models=await this.enrichModels(msg.models||[]);for(const m of models)if(!msg.modelNames.includes(m.displayName))msg.modelNames.push(m.displayName)}catch(e){console.warn("cursor-openai-byok model patch failed",e)}},async runAgent(payload,onEvent){const res=await fetch(endpoint+"/cursor/v1/run-agent-loop",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(payload)});if(!res.ok)throw new Error("BYOK HTTP "+res.status);const reader=res.body.getReader();const decoder=new TextDecoder();let buf="";for(;;){const item=await reader.read();if(item.done)break;buf+=decoder.decode(item.value,{stream:true});let idx;while((idx=buf.indexOf("\\n"))>=0){const line=buf.slice(0,idx).trim();buf=buf.slice(idx+1);if(line){try{await onEvent(JSON.parse(line))}catch(e){console.warn("cursor-openai-byok event failed",e)}}}}}};globalThis.${MARKER}=byok;return byok}`;
+}
+
+function agentLoopSnippet(vars) {
+  const v = vars || {
+    model: "h",
+    adapter: "oe",
+    ctx: "_e",
+    event: "e",
+    userText: "o",
+    richText: "a",
+    mode: "c",
+    selectedContext: "d",
+    requestContext: "m",
+    generationUUID: "f",
+    conversationId: "v",
+    messageId: "b",
+    conversationState: "W",
+  };
+  return `if(!${v.event}.subagentTypeName&&await ${MARKER}().shouldHandle(${v.model}?.modelName)){const sendText=async text=>{if(text)await ${v.adapter}.sendUpdate(${v.ctx}.ctx,E0c.textDelta(text))};const sendDone=async()=>{await ${v.adapter}.sendUpdate(${v.ctx}.ctx,E0c.turnEnded())};try{await ${MARKER}().runAgent({model:${v.model}?.modelName,userText:${v.userText},richText:${v.richText},mode:${v.mode},selectedContext:${v.selectedContext},requestContext:${v.requestContext},generationUUID:${v.generationUUID},conversationId:${v.conversationId},messageId:${v.messageId},conversationState:${v.conversationState},event:${v.event},tools:${v.event}.tools},async ev=>{if(ev.type==="text_delta")await sendText(ev.text||"");else if(ev.type==="tool_calls_ready")await sendText("\\n[BYOK tool calls requested: "+(ev.toolCalls||[]).map(t=>t.name||t.id).join(", ")+"]\\n");else if(ev.type==="error")await sendText("Local BYOK error: "+(ev.error||"unknown"));});await sendDone();return}catch(err){await sendText("Local BYOK error: "+(err&&err.message?err.message:String(err)));await sendDone();return}}`;
+}
+
+module.exports = { MARKER, LEGACY_MARKER, helperSnippet, agentLoopSnippet };
+
+}
+};
+const __bundleCache = Object.create(null);
+const __bundleNodeRequire = require;
+
+function __bundleNormalize(id) {
+  return id.split(__bundlePath.sep).join("/");
+}
+
+function __bundleResolve(fromId, request) {
+  if (!request.startsWith(".")) return null;
+  const base = __bundlePath.resolve(__bundleRoot, __bundlePath.dirname(fromId), request);
+  for (const candidate of [base, base + ".js", __bundlePath.join(base, "index.js")]) {
+    const id = __bundleNormalize(__bundlePath.relative(__bundleRoot, candidate));
+    if (__bundleModules[id]) return id;
+  }
+  throw new Error("Cannot resolve " + request + " from " + fromId);
+}
+
+function __bundleRequire(id) {
+  if (__bundleCache[id]) return __bundleCache[id].exports;
+  const factory = __bundleModules[id];
+  if (!factory) return __bundleNodeRequire(id);
+  const module = { exports: {} };
+  __bundleCache[id] = module;
+  const filename = __bundlePath.join(__bundleRoot, id);
+  const dirname = __bundlePath.dirname(filename);
+  function localRequire(request) {
+    const localId = __bundleResolve(id, request);
+    return localId ? __bundleRequire(localId) : __bundleNodeRequire(request);
+  }
+  factory(module, module.exports, localRequire, filename, dirname);
+  return module.exports;
+}
+
+module.exports = __bundleRequire("src/cli/index.js");