impel-cli 0.18.15 → 0.18.16

package/src/cursorLocal.js

@@ -0,0 +1,1554 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+
+import { codesignIdentityArgs, desiredSigningMode, resolveSigningIdentity } from "./codesign.js";
+import { brandedEnvironmentName, RUNTIME_BRAND } from "./runtimeBrand.js";
+import { normalizeTenantId } from "./tenants.js";
+
+export const CURSOR_VENDOR_BUNDLE_ID = "com.todesktop.230313mzl4w4u92";
+export const CURSOR_VENDOR_TEAM_ID = "VDXQ22DGB9";
+export const CURSOR_RUNTIME_SCHEMA_VERSION = 5;
+
+export const CURSOR_LOCAL_MODE_FILES = Object.freeze([
+  "extensions/cursor-commits/dist/main.js",
+  "extensions/cursor-retrieval/dist/main.js",
+  "out/main.js",
+  "out/vs/code/electron-utility/alwaysLocalSingleton/alwaysLocalSingletonMain.js",
+  "out/vs/code/electron-utility/mcpProcess/mcpProcessMain.js",
+  "out/vs/code/electron-utility/sharedProcess/sharedProcessMain.js",
+  "out/vs/workbench/api/node/extensionHostProcess.js",
+  "out/vs/workbench/api/worker/extensionHostWorkerMain.js",
+  "out/vs/workbench/workbench.desktop.main.js",
+  "out/vs/workbench/workbench.glass.main.js",
+]);
+
+const CURSOR_PROVIDER_LOCK_FILES = Object.freeze([
+  "out/vs/workbench/workbench.desktop.main.js",
+  "out/vs/workbench/workbench.glass.main.js",
+]);
+const CURSOR_VERIFIED_EXTENSIONS = Object.freeze([
+  Object.freeze({ id: "anysphere.cursor-commits", relative: "extensions/cursor-commits/dist/main.js" }),
+  Object.freeze({ id: "anysphere.cursor-retrieval", relative: "extensions/cursor-retrieval/dist/main.js" }),
+]);
+
+const CURSOR_LOCAL_RUNTIME_FILE = "extensions/cursor-local-agent-runtime/dist/main.js";
+const CURSOR_REASONING_TRANSPORT_DISABLED = 'void 0===a?(delete e.reasoning,delete e.reasoning_effort):"output_config.effort"===a.param?';
+const CURSOR_REASONING_TRANSPORT_ENABLED = 'void 0===a?"responses"===o?(e.reasoning=Object.assign(Object.assign({},qRt(e.reasoning)?e.reasoning:{}),{effort:i}),delete e.reasoning_effort):(delete e.reasoning,delete e.reasoning_effort):"output_config.effort"===a.param?';
+const CURSOR_HELPER_BUNDLES = Object.freeze([
+  "Cursor Helper (GPU).app",
+  "Cursor Helper (Plugin).app",
+  "Cursor Helper (Renderer).app",
+  "Cursor Helper.app",
+]);
+const PRODUCT_FILE = "product.json";
+const PACKAGE_FILE = "package.json";
+const LOCAL_MODE_DISABLED = "localMode:!1";
+const LOCAL_MODE_ENABLED = "localMode:!0";
+const PERSONAL_DATA_IMPORT_GUARD = "if(!Ui.localMode)";
+const MANAGED_DATA_IMPORT_GUARD = "if(Ui.localMode )";
+const DISABLE_LIBRARY_VALIDATION_ENTITLEMENT = "com.apple.security.cs.disable-library-validation";
+const DIRECT_PROVIDER_ENV_KEYS = Object.freeze([
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_DEFAULT_REGION",
+  "AWS_PROFILE",
+  "AWS_REGION",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN",
+  "AZURE_OPENAI_API_KEY",
+  "AZURE_OPENAI_ENDPOINT",
+  "CURSOR_API_KEY",
+  "CURSOR_LOCAL_AGENT_API_KEY",
+  "CURSOR_LOCAL_AGENT_BASE_URL",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENAI_BASE_URL",
+  "OPENAI_ORG_ID",
+]);
+const ISOLATION_BREAKING_ARGUMENTS = Object.freeze([
+  "--extensions-dir",
+  "--override-cursor-auth-token",
+  "--user-data-dir",
+]);
+const RUNTIME_OVERRIDE_ENV_KEYS = Object.freeze([
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_PLUGIN_ROOT",
+  "CODEX_HOME",
+  "CURSOR_PLUGIN_ROOT",
+  "ELECTRON_RUN_AS_NODE",
+  "NODE_OPTIONS",
+  "NODE_PATH",
+  "VSCODE_PORTABLE",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+]);
+const CURSOR_IPC_SOCKET_PATH_LIMIT = 103;
+const CURSOR_IPC_SOCKET_SUFFIX_RESERVE = Buffer.byteLength("/999.999-main.sock");
+const CURSOR_PREPARE_LOCK_FILE = ".prepare.lock";
+const CURSOR_REACTIVE_STORAGE_KEY = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
+const CURSOR_MANAGED_MODELS_KEY = "impel.cursor.gatewayModels";
+const CURSOR_MANAGED_GATEWAY_SENTINEL = "impel-managed-non-secret";
+const MACOS_O_EXLOCK = 0x00000020;
+const portableCursorPrepareLocks = new Set();
+
+function appResources(appPath) {
+  return path.join(appPath, "Contents", "Resources", "app");
+}
+
+function cursorProcessBundles(appPath) {
+  const frameworks = path.join(appPath, "Contents", "Frameworks");
+  let found;
+  try {
+    found = fs.readdirSync(frameworks, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.endsWith(".app"))
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    throw new Error(`Cursor helper bundle contract is unavailable: ${error?.message || error}`);
+  }
+  assertStringArrayEqual(found, [...CURSOR_HELPER_BUNDLES], "Cursor helper bundle surface");
+  return [
+    ...CURSOR_HELPER_BUNDLES.map((name) => path.join(frameworks, name)),
+    appPath,
+  ];
+}
+
+function countOccurrences(value, needle) {
+  let count = 0;
+  let offset = 0;
+  while ((offset = value.indexOf(needle, offset)) !== -1) {
+    count += 1;
+    offset += needle.length;
+  }
+  return count;
+}
+
+function sha256File(filePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function sha256FileBase64(filePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("base64").replace(/=+$/u, "");
+}
+
+function cursorExtensionIntegrityHash(source, id) {
+  const token = `"${id}":{dist:{"main.js":"`;
+  const first = source.indexOf(token);
+  if (first === -1 || source.indexOf(token, first + token.length) !== -1) {
+    throw new Error(`Cursor extension-integrity contract changed for ${id}`);
+  }
+  const start = first + token.length;
+  const hash = source.slice(start, start + 64);
+  if (!/^[0-9a-f]{64}$/u.test(hash) || source.slice(start + 64, start + 66) !== '"}') {
+    throw new Error(`Cursor extension-integrity hash changed for ${id}`);
+  }
+  return { hash, start };
+}
+
+function assertCursorExtensionIntegrityContract(resourcesRoot) {
+  const hostPath = path.join(resourcesRoot, "out", "vs", "workbench", "api", "node", "extensionHostProcess.js");
+  const host = fs.readFileSync(hostPath, "utf8");
+  return CURSOR_VERIFIED_EXTENSIONS.map(({ id, relative }) => {
+    const embedded = cursorExtensionIntegrityHash(host, id).hash;
+    const actual = sha256File(path.join(resourcesRoot, relative));
+    if (embedded !== actual) {
+      throw new Error(`Cursor vendor extension integrity does not match ${relative}; review this update before use`);
+    }
+    return { id, relative, vendorHash: embedded };
+  });
+}
+
+function patchCursorExtensionIntegrity(resourcesRoot, reviewed) {
+  const hostPath = path.join(resourcesRoot, "out", "vs", "workbench", "api", "node", "extensionHostProcess.js");
+  let host = fs.readFileSync(hostPath, "utf8");
+  const originalLength = Buffer.byteLength(host);
+  for (const { id, relative, vendorHash } of reviewed) {
+    const embedded = cursorExtensionIntegrityHash(host, id);
+    if (embedded.hash !== vendorHash) {
+      throw new Error(`Cursor extension-integrity source changed while patching ${id}`);
+    }
+    const managedHash = sha256File(path.join(resourcesRoot, relative));
+    host = `${host.slice(0, embedded.start)}${managedHash}${host.slice(embedded.start + 64)}`;
+  }
+  if (Buffer.byteLength(host) !== originalLength) {
+    throw new Error("Cursor extension-integrity patch changed byte width");
+  }
+  fs.writeFileSync(hostPath, host);
+  return reviewed.length;
+}
+
+function readJSON(filePath, label) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`${label} is missing or invalid: ${error?.message || error}`);
+  }
+}
+
+function cursorProductChecksumEntries(resourcesRoot) {
+  const productPath = path.join(resourcesRoot, PRODUCT_FILE);
+  const product = readJSON(productPath, "Cursor product.json");
+  if (
+    !product.checksums
+    || typeof product.checksums !== "object"
+    || Array.isArray(product.checksums)
+    || Object.keys(product.checksums).length === 0
+  ) {
+    throw new Error("Cursor product checksum contract is missing; review this update before use");
+  }
+  const outRoot = path.join(resourcesRoot, "out");
+  const entries = Object.entries(product.checksums).map(([relative, expected]) => {
+    const normalized = path.posix.normalize(relative);
+    if (
+      normalized !== relative
+      || path.posix.isAbsolute(relative)
+      || relative === ".."
+      || relative.startsWith("../")
+      || typeof expected !== "string"
+      || !/^[A-Za-z0-9+/]{43}$/u.test(expected)
+    ) {
+      throw new Error(`Cursor product checksum entry is invalid: ${relative}`);
+    }
+    const target = path.join(outRoot, ...relative.split("/"));
+    if (!fs.statSync(target, { throwIfNoEntry: false })?.isFile()) {
+      throw new Error(`Cursor product checksum target is missing: ${relative}`);
+    }
+    return { expected, relative, target };
+  });
+  return { entries, product, productPath };
+}
+
+function assertCursorProductChecksums(resourcesRoot) {
+  const { entries } = cursorProductChecksumEntries(resourcesRoot);
+  for (const { expected, relative, target } of entries) {
+    if (sha256FileBase64(target) !== expected) {
+      throw new Error(`Cursor product checksum does not match ${relative}`);
+    }
+  }
+  return entries.length;
+}
+
+function patchCursorProductChecksums(resourcesRoot) {
+  const { entries, product, productPath } = cursorProductChecksumEntries(resourcesRoot);
+  product.checksums = Object.fromEntries(entries.map(({ relative, target }) => [
+    relative,
+    sha256FileBase64(target),
+  ]));
+  fs.writeFileSync(productPath, JSON.stringify(product));
+  assertCursorProductChecksums(resourcesRoot);
+  return entries.length;
+}
+
+function runResult(command, args) {
+  return spawnSync(command, args, { encoding: "utf8" });
+}
+
+function commandFailure(label, result) {
+  const detail = result?.error?.message
+    || String(result?.stderr || result?.stdout || "").trim()
+    || `exit ${result?.status ?? "unknown"}`;
+  return new Error(`${label} failed: ${detail}`);
+}
+
+function defaultVerifyVendorBundle(appPath) {
+  const verified = runResult("/usr/bin/codesign", ["--verify", "--deep", "--strict", appPath]);
+  if (verified.status !== 0 || verified.error) throw commandFailure("Cursor vendor signature verification", verified);
+  const details = runResult("/usr/bin/codesign", ["-dv", "--verbose=4", appPath]);
+  if (details.status !== 0 || details.error) throw commandFailure("Cursor vendor signature inspection", details);
+  const output = `${details.stdout || ""}\n${details.stderr || ""}`;
+  const bundleIdentifier = output.match(/^Identifier=(.+)$/mu)?.[1]?.trim();
+  const teamIdentifier = output.match(/^TeamIdentifier=(.+)$/mu)?.[1]?.trim();
+  const developerID = output.match(/^Authority=Developer ID Application:/mu) !== null;
+  if (bundleIdentifier !== CURSOR_VENDOR_BUNDLE_ID || teamIdentifier !== CURSOR_VENDOR_TEAM_ID || !developerID) {
+    throw new Error(
+      `unsupported Cursor signature (bundle ${bundleIdentifier || "unknown"}, team ${teamIdentifier || "unknown"})`,
+    );
+  }
+  return { bundleIdentifier, teamIdentifier };
+}
+
+function localModeFiles(resourcesRoot, marker = LOCAL_MODE_DISABLED) {
+  const found = [];
+  const roots = [path.join(resourcesRoot, "out"), path.join(resourcesRoot, "extensions")];
+  const visit = (directory) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error?.code === "ENOENT") return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(absolute);
+      } else if (entry.isFile() && entry.name.endsWith(".js")) {
+        const contents = fs.readFileSync(absolute, "utf8");
+        if (contents.includes(marker)) {
+          found.push(path.relative(resourcesRoot, absolute).split(path.sep).join("/"));
+        }
+      }
+    }
+  };
+  for (const root of roots) visit(root);
+  return found.sort();
+}
+
+function assertStringArrayEqual(actual, expected, label) {
+  if (actual.length !== expected.length || actual.some((entry, index) => entry !== expected[index])) {
+    throw new Error(
+      `${label} changed (found ${actual.length ? actual.join(", ") : "none"}); review this Cursor update before use`,
+    );
+  }
+}
+
+function assertLocalRuntimeContract(resourcesRoot) {
+  const runtimePath = path.join(resourcesRoot, CURSOR_LOCAL_RUNTIME_FILE);
+  let runtime;
+  try {
+    runtime = fs.readFileSync(runtimePath, "utf8");
+  } catch (error) {
+    throw new Error(`Cursor local-agent runtime is unavailable: ${error?.message || error}`);
+  }
+  const markers = [
+    "apiKeyHelper",
+    "api_types",
+    "anthropic_messages",
+    "fetchLocalProviderModels",
+    "max_output_tokens",
+    "openai_responses",
+    "supports_streaming",
+    "supports_tool_use",
+  ];
+  const missing = markers.filter((marker) => !runtime.includes(marker));
+  if (missing.length) {
+    throw new Error(`Cursor local-agent runtime contract changed (missing ${missing.join(", ")}); review this update before use`);
+  }
+  const responseEndpointSelection = /\.includes\("responses"\)\|\|[^?]{0,120}\.includes\("openai_responses"\)\?"responses":/u;
+  const chatCompletionsEndpointSelection = /\.includes\("chat_completions"\)\|\|[^?]{0,120}\.includes\("openai_chat"\)\?"chat_completions":/u;
+  const anthropicApiTypeSelection = /\.includes\("anthropic_messages"\)&&![^?]{0,80}\?"anthropic_messages":"openai_compatible"/u;
+  if (
+    !responseEndpointSelection.test(runtime)
+    || !chatCompletionsEndpointSelection.test(runtime)
+    || !anthropicApiTypeSelection.test(runtime)
+  ) {
+    throw new Error("Cursor local-agent Responses/model-picker contract changed; review this update before use");
+  }
+  if (countOccurrences(runtime, CURSOR_REASONING_TRANSPORT_DISABLED) !== 1) {
+    throw new Error("Cursor local-agent reasoning-effort transport contract changed; review this update before use");
+  }
+  return runtime;
+}
+
+function patchCursorReasoningTransport(resourcesRoot) {
+  const runtimePath = path.join(resourcesRoot, CURSOR_LOCAL_RUNTIME_FILE);
+  const runtime = fs.readFileSync(runtimePath, "utf8");
+  if (countOccurrences(runtime, CURSOR_REASONING_TRANSPORT_DISABLED) !== 1) {
+    throw new Error("Cursor local-agent reasoning-effort transport contract changed; refusing to patch");
+  }
+  fs.writeFileSync(
+    runtimePath,
+    runtime.replace(CURSOR_REASONING_TRANSPORT_DISABLED, CURSOR_REASONING_TRANSPORT_ENABLED),
+  );
+  return 1;
+}
+
+function assertCursorAuthenticationContract(resourcesRoot) {
+  const main = fs.readFileSync(path.join(resourcesRoot, "out", "main.js"), "utf8");
+  for (const marker of [
+    '"skip-welcome":{type:"boolean"}',
+    '"skip-onboarding":{type:"boolean"}',
+    '"override-cursor-auth-token":{type:"string"}',
+  ]) {
+    if (countOccurrences(main, marker) !== 1) {
+      throw new Error("Cursor managed-authentication argument contract changed; review this update before use");
+    }
+  }
+  for (const relative of CURSOR_PROVIDER_LOCK_FILES) {
+    const source = fs.readFileSync(path.join(resourcesRoot, relative), "utf8");
+    for (const marker of [
+      "workbench.action.devAutoLoginFakeForTesting",
+      "cursor-smoke-test",
+      "fake-refresh-token-for-testing",
+      "cursorAuth/accessToken",
+      "cursorAuth/refreshToken",
+      "overrideCursorAuthToken",
+    ]) {
+      if (!source.includes(marker)) {
+        throw new Error(`Cursor managed-authentication contract changed in ${relative}; review this update before use`);
+      }
+    }
+  }
+}
+
+function assertCursorDataImportContract(resourcesRoot) {
+  const mainPath = path.join(resourcesRoot, "out", "main.js");
+  const source = fs.readFileSync(mainPath, "utf8");
+  const required = [
+    "Cursor data import is only available in local mode",
+    "localModeDataImportService",
+    "async getAvailability()",
+    "async stageImport(e)",
+    "async relaunchPreparedImport(e)",
+  ];
+  if (required.some((marker) => !source.includes(marker)) || countOccurrences(source, PERSONAL_DATA_IMPORT_GUARD) !== 5) {
+    throw new Error("Cursor personal-data import contract changed; review this update before use");
+  }
+}
+
+function contractFingerprint(product, packageJSON, resourcesRoot, runtime, executable) {
+  const hash = crypto.createHash("sha256");
+  hash.update(JSON.stringify({
+    applicationName: product.applicationName,
+    commit: product.commit,
+    darwinBundleIdentifier: product.darwinBundleIdentifier,
+    nameLong: product.nameLong,
+    quality: product.quality,
+    version: product.version,
+  }));
+  hash.update(JSON.stringify({ name: packageJSON.name, version: packageJSON.version }));
+  for (const relative of CURSOR_LOCAL_MODE_FILES) {
+    const contents = fs.readFileSync(path.join(resourcesRoot, relative));
+    hash.update(relative);
+    hash.update(contents);
+  }
+  hash.update(CURSOR_LOCAL_RUNTIME_FILE);
+  hash.update(runtime);
+  hash.update("Contents/MacOS/Cursor");
+  hash.update(fs.readFileSync(executable));
+  return hash.digest("hex");
+}
+
+export function inspectCursorVendorApp(appPath, dependencies = {}) {
+  if (!appPath || !fs.statSync(appPath, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new Error(`Cursor vendor app was not found at ${appPath || "(missing path)"}`);
+  }
+  const verifyVendorBundle = dependencies.verifyVendorBundle || defaultVerifyVendorBundle;
+  const signature = verifyVendorBundle(appPath);
+  if (
+    signature?.bundleIdentifier !== CURSOR_VENDOR_BUNDLE_ID
+    || signature?.teamIdentifier !== CURSOR_VENDOR_TEAM_ID
+  ) {
+    throw new Error("Cursor vendor verifier did not establish the expected bundle and Developer ID team");
+  }
+  const resourcesRoot = appResources(appPath);
+  const product = readJSON(path.join(resourcesRoot, PRODUCT_FILE), "Cursor product.json");
+  const packageJSON = readJSON(path.join(resourcesRoot, PACKAGE_FILE), "Cursor package.json");
+  if (
+    product.nameLong !== "Cursor"
+    || product.applicationName !== "cursor"
+    || product.quality !== "stable"
+    || product.darwinBundleIdentifier !== CURSOR_VENDOR_BUNDLE_ID
+    || typeof product.version !== "string"
+    || !/^\d+\.\d+\.\d+$/u.test(product.version)
+    || typeof product.commit !== "string"
+    || !/^[0-9a-f]{40}$/u.test(product.commit)
+  ) {
+    throw new Error("unsupported Cursor product contract; only a signed stable Cursor desktop build can be managed");
+  }
+  if (packageJSON.name !== "Cursor" || packageJSON.version !== product.version) {
+    throw new Error("unsupported Cursor Electron package contract; review this update before use");
+  }
+  const executable = path.join(appPath, "Contents", "MacOS", "Cursor");
+  if (!fs.statSync(executable, { throwIfNoEntry: false })?.isFile()) {
+    throw new Error("Cursor vendor executable is missing");
+  }
+  cursorProcessBundles(appPath);
+  const found = localModeFiles(resourcesRoot);
+  assertStringArrayEqual(found, [...CURSOR_LOCAL_MODE_FILES].sort(), "Cursor local-mode source surface");
+  const alreadyEnabled = localModeFiles(resourcesRoot, LOCAL_MODE_ENABLED);
+  if (alreadyEnabled.length) {
+    throw new Error(`Cursor vendor app already contains enabled local-mode surfaces (${alreadyEnabled.join(", ")}); review this update before use`);
+  }
+  for (const relative of CURSOR_LOCAL_MODE_FILES) {
+    const source = fs.readFileSync(path.join(resourcesRoot, relative), "utf8");
+    if (countOccurrences(source, LOCAL_MODE_DISABLED) !== 1) {
+      throw new Error(`Cursor local-mode signature changed in ${relative}; review this update before use`);
+    }
+  }
+  for (const relative of CURSOR_PROVIDER_LOCK_FILES) {
+    assertProviderCandidateContract(fs.readFileSync(path.join(resourcesRoot, relative), "utf8"), relative);
+  }
+  assertCursorExtensionIntegrityContract(resourcesRoot);
+  assertCursorDataImportContract(resourcesRoot);
+  assertCursorAuthenticationContract(resourcesRoot);
+  assertCursorProductChecksums(resourcesRoot);
+  const runtime = assertLocalRuntimeContract(resourcesRoot);
+  return {
+    appPath,
+    bundleIdentifier: signature.bundleIdentifier,
+    teamIdentifier: signature.teamIdentifier,
+    version: product.version,
+    commit: product.commit,
+    sourceFingerprint: contractFingerprint(product, packageJSON, resourcesRoot, runtime, executable),
+  };
+}
+
+function matchingBracket(value, openingIndex, open, close) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openingIndex; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote) quote = null;
+      continue;
+    }
+    if (character === "\"" || character === "'" || character === "`") {
+      quote = character;
+    } else if (character === open) {
+      depth += 1;
+    } else if (character === close) {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function uniqueArrayRange(source, token, label) {
+  const first = source.indexOf(token);
+  if (first === -1 || source.indexOf(token, first + token.length) !== -1) {
+    throw new Error(`Cursor ${label} candidate contract changed`);
+  }
+  const opening = first + token.length - 1;
+  const closing = matchingBracket(source, opening, "[", "]");
+  if (closing === -1) throw new Error(`Cursor ${label} candidate array is malformed`);
+  return { opening, closing };
+}
+
+function splitTopLevelArray(source, range, label) {
+  const body = source.slice(range.opening + 1, range.closing);
+  const entries = [];
+  let start = 0;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < body.length; index += 1) {
+    const character = body[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote) quote = null;
+      continue;
+    }
+    if (character === "\"" || character === "'" || character === "`") quote = character;
+    else if (character === "{") braceDepth += 1;
+    else if (character === "}") braceDepth -= 1;
+    else if (character === "[") bracketDepth += 1;
+    else if (character === "]") bracketDepth -= 1;
+    else if (character === "(") parenDepth += 1;
+    else if (character === ")") parenDepth -= 1;
+    else if (character === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+      entries.push(body.slice(start, index));
+      start = index + 1;
+    }
+  }
+  entries.push(body.slice(start));
+  if (entries.length !== 4 || entries.some((entry) => !entry.startsWith("{value:") || !entry.endsWith("}"))) {
+    throw new Error(`Cursor ${label} candidate list changed`);
+  }
+  return entries;
+}
+
+function candidateKind(entry, label) {
+  if (entry.includes(`CURSOR_LOCAL_AGENT_${label === "API key" ? "API_KEY" : "BASE_URL"}`)) return "cursor";
+  if (entry.includes(label === "API key" ? "ANTHROPIC_AUTH_TOKEN" : "ANTHROPIC_BASE_URL")) return "compatibility";
+  if (entry.includes(label === "API key" ? ".modelProvidedApiKey" : ".modelProvidedBaseUrl")) return "model";
+  if (entry.includes(label === "API key" ? ".storedOpenAIKey" : ".openAIBaseUrl")) return "stored";
+  throw new Error(`Cursor ${label} candidate source changed`);
+}
+
+function providerCandidateArray(source, token, label) {
+  const range = uniqueArrayRange(source, token, label);
+  const entries = splitTopLevelArray(source, range, label);
+  const kinds = entries.map((entry) => candidateKind(entry, label));
+  assertStringArrayEqual(kinds, ["model", "stored", "cursor", "compatibility"], `Cursor ${label} priority`);
+  return { range, entries, kinds };
+}
+
+function assertProviderCandidateContract(source, relative) {
+  try {
+    providerCandidateArray(source, "apiKeyCandidates:[", "API key");
+    providerCandidateArray(source, "baseUrlCandidates:[", "base URL");
+  } catch (error) {
+    throw new Error(`${error.message} in ${relative}; review this Cursor update before use`);
+  }
+}
+
+function prioritizeManagedProvider(source, relative) {
+  const arrays = [
+    providerCandidateArray(source, "apiKeyCandidates:[", "API key"),
+    providerCandidateArray(source, "baseUrlCandidates:[", "base URL"),
+  ].sort((left, right) => right.range.opening - left.range.opening);
+  let patched = source;
+  for (const { range, entries, kinds } of arrays) {
+    const byKind = new Map(kinds.map((kind, index) => [
+      kind,
+      ["model", "stored"].includes(kind) ? disableProviderCandidate(entries[index], relative) : entries[index],
+    ]));
+    const replacement = ["cursor", "compatibility", "model", "stored"]
+      .map((kind) => byKind.get(kind))
+      .join(",");
+    const originalLength = range.closing - range.opening - 1;
+    if (replacement.length !== originalLength) {
+      throw new Error(`Cursor managed-provider patch changed byte width in ${relative}`);
+    }
+    patched = `${patched.slice(0, range.opening + 1)}${replacement}${patched.slice(range.closing)}`;
+  }
+  return patched;
+}
+
+function disableProviderCandidate(entry, relative) {
+  const valueStart = entry.indexOf("{value:") + "{value:".length;
+  const sourceStart = entry.lastIndexOf(",source:");
+  if (valueStart < "{value:".length || sourceStart <= valueStart) {
+    throw new Error(`Cursor managed-provider fallback contract changed in ${relative}`);
+  }
+  const width = sourceStart - valueStart;
+  if (width < "void 0".length) throw new Error(`Cursor managed-provider fallback is too narrow in ${relative}`);
+  return `${entry.slice(0, valueStart)}${"void 0".padEnd(width, " ")}${entry.slice(sourceStart)}`;
+}
+
+export function managedCursorApplicationName(tenantId) {
+  return `${RUNTIME_BRAND.apps.displayPrefix} Cursor [${normalizeTenantId(tenantId)}]`;
+}
+
+function patchCursorApplicationName(resourcesRoot, applicationName) {
+  const packagePath = path.join(resourcesRoot, PACKAGE_FILE);
+  const source = fs.readFileSync(packagePath, "utf8");
+  const parsed = readJSON(packagePath, "Cursor package.json");
+  if (parsed.name !== "Cursor") throw new Error("Cursor Electron application-name contract changed; refusing to patch");
+  const needle = '"name": "Cursor"';
+  if (countOccurrences(source, needle) !== 1) {
+    throw new Error("Cursor Electron application-name source signature changed; refusing to patch");
+  }
+  fs.writeFileSync(packagePath, source.replace(needle, `"name": ${JSON.stringify(applicationName)}`));
+  return 1;
+}
+
+function disableCursorPersonalDataImport(resourcesRoot) {
+  const mainPath = path.join(resourcesRoot, "out", "main.js");
+  const source = fs.readFileSync(mainPath, "utf8");
+  assertCursorDataImportContract(resourcesRoot);
+  const patched = source.replaceAll(PERSONAL_DATA_IMPORT_GUARD, MANAGED_DATA_IMPORT_GUARD);
+  if (Buffer.byteLength(patched) !== Buffer.byteLength(source)) {
+    throw new Error("Cursor personal-data import patch changed byte width");
+  }
+  fs.writeFileSync(mainPath, patched);
+  return 5;
+}
+
+export function patchCursorBundle(bundlePath, { applicationName } = {}) {
+  if (!applicationName) throw new Error("a tenant-specific Cursor application name is required");
+  const resourcesRoot = appResources(bundlePath);
+  const reviewedExtensionIntegrity = assertCursorExtensionIntegrityContract(resourcesRoot);
+  const isolatedApplicationName = patchCursorApplicationName(resourcesRoot, applicationName);
+  const disabledPersonalDataImport = disableCursorPersonalDataImport(resourcesRoot);
+  let localModePatches = 0;
+  let providerOnlyPatches = 0;
+  for (const relative of CURSOR_LOCAL_MODE_FILES) {
+    const target = path.join(resourcesRoot, relative);
+    const source = fs.readFileSync(target, "utf8");
+    if (countOccurrences(source, LOCAL_MODE_DISABLED) !== 1) {
+      throw new Error(`Cursor local-mode signature changed in ${relative}; refusing to patch`);
+    }
+    let patched = source.replace(LOCAL_MODE_DISABLED, LOCAL_MODE_ENABLED);
+    if (CURSOR_PROVIDER_LOCK_FILES.includes(relative)) {
+      patched = prioritizeManagedProvider(patched, relative);
+      providerOnlyPatches += 1;
+    }
+    if (Buffer.byteLength(patched) !== Buffer.byteLength(source)) {
+      throw new Error(`Cursor fixed-width patch changed ${relative} size`);
+    }
+    fs.writeFileSync(target, patched);
+    localModePatches += 1;
+  }
+  const extensionIntegrity = patchCursorExtensionIntegrity(resourcesRoot, reviewedExtensionIntegrity);
+  const reasoningTransport = patchCursorReasoningTransport(resourcesRoot);
+  const productChecksums = patchCursorProductChecksums(resourcesRoot);
+  return {
+    disabledPersonalDataImport,
+    extensionIntegrity,
+    isolatedApplicationName,
+    localMode: localModePatches,
+    managedProviderOnly: providerOnlyPatches,
+    productChecksums,
+    reasoningTransport,
+  };
+}
+
+export function cursorManagedPaths(homeDir = os.homedir(), tenantId, options = {}) {
+  const normalizedTenant = normalizeTenantId(tenantId);
+  const appRoot = options.appRoot
+    || process.env[brandedEnvironmentName("APP_HOME")]
+    || path.join(homeDir, ".config", RUNTIME_BRAND.cli.configNamespace, "apps");
+  const root = path.join(appRoot, "tenants", normalizedTenant, "cursor");
+  const generation = path.join(root, "runtime", "current");
+  return {
+    root,
+    home: path.join(root, "home"),
+    runtimeRoot: path.join(root, "runtime"),
+    generation,
+    bundle: path.join(generation, "Cursor.app"),
+    manifest: path.join(generation, "manifest.json"),
+    userData: path.join(root, "user-data"),
+    extensions: path.join(root, "extensions"),
+  };
+}
+
+export function resolveCursorVendorApp(homeDir = os.homedir(), environment = process.env) {
+  const explicit = String(environment.IMPEL_CURSOR_VENDOR_APP || "").trim();
+  const candidates = explicit
+    ? [path.resolve(explicit)]
+    : ["/Applications/Cursor.app", path.join(homeDir, "Applications", "Cursor.app")];
+  const found = candidates.find((candidate) => fs.statSync(candidate, { throwIfNoEntry: false })?.isDirectory());
+  if (!found) throw new Error("Cursor.app is not installed; install the stable Cursor desktop app first");
+  return found;
+}
+
+function defaultCloneBundle(source, destination) {
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  const cloned = spawnSync("/bin/cp", ["-cR", source, destination], { encoding: "utf8" });
+  if (cloned.status === 0 && !cloned.error) return;
+  fs.rmSync(destination, { recursive: true, force: true });
+  fs.cpSync(source, destination, { recursive: true, dereference: false, preserveTimestamps: true });
+}
+
+function defaultSignManagedBundle(bundle) {
+  const identity = resolveSigningIdentity();
+  spawnSync("/usr/bin/xattr", ["-dr", "com.apple.quarantine", bundle], { stdio: "ignore" });
+  const signed = runResult("/usr/bin/codesign", [
+    "--force",
+    "--deep",
+    "--options",
+    "runtime",
+    "--preserve-metadata=entitlements,flags,runtime",
+    ...codesignIdentityArgs(identity),
+    bundle,
+  ]);
+  if (signed.status !== 0 || signed.error) throw commandFailure("managed Cursor signing", signed);
+  const entitlementFiles = [];
+  try {
+    // A self-signed (or ad-hoc) local identity has no Apple Team ID. Electron's
+    // hardened main and helper processes would therefore refuse to map their
+    // separately identified Electron framework even though every individual
+    // signature passes `codesign --deep --strict`. Preserve each vendor
+    // entitlement set while disabling library validation on every process.
+    for (const target of cursorProcessBundles(bundle)) {
+      const entitlements = readCursorEntitlements(target);
+      const entitlementFile = path.join(
+        os.tmpdir(),
+        `impel-cursor-entitlements-${process.pid}-${crypto.randomBytes(4).toString("hex")}.plist`,
+      );
+      entitlementFiles.push(entitlementFile);
+      fs.writeFileSync(entitlementFile, cursorEntitlementsWithDisabledLibraryValidation(entitlements), { mode: 0o600 });
+      const restored = runResult("/usr/bin/codesign", [
+        "--force",
+        "--options",
+        "runtime",
+        "--entitlements",
+        entitlementFile,
+        ...codesignIdentityArgs(identity),
+        target,
+      ]);
+      if (restored.status !== 0 || restored.error) {
+        throw commandFailure("managed Cursor capability signing", restored);
+      }
+    }
+  } finally {
+    for (const entitlementFile of entitlementFiles) fs.rmSync(entitlementFile, { force: true });
+  }
+  return identity.mode === "external" ? identity.descriptor : identity.mode;
+}
+
+function readCursorEntitlements(target) {
+  const inspected = runResult("/usr/bin/codesign", ["-d", "--entitlements", ":-", target]);
+  if (inspected.status !== 0 || inspected.error) {
+    throw commandFailure("managed Cursor entitlement inspection", inspected);
+  }
+  const source = String(inspected.stdout || "").trim();
+  if (!source.startsWith("<?xml") || !source.endsWith("</plist>")) {
+    throw new Error("managed Cursor entitlement inspection returned an unsupported plist");
+  }
+  return source;
+}
+
+export function cursorEntitlementsWithDisabledLibraryValidation(source) {
+  const key = `<key>${DISABLE_LIBRARY_VALIDATION_ENTITLEMENT}</key>`;
+  const occurrences = countOccurrences(source, key);
+  if (occurrences > 1) throw new Error("Cursor library-validation entitlement is ambiguous");
+  if (occurrences === 1) {
+    const value = source.slice(source.indexOf(key) + key.length);
+    if (!/^\s*<true\s*\/>/u.test(value)) {
+      throw new Error("Cursor library-validation entitlement is not enabled");
+    }
+    return source;
+  }
+  if (countOccurrences(source, "</dict>") !== 1) {
+    throw new Error("Cursor entitlement plist contract changed");
+  }
+  return source.replace("</dict>", `${key}<true/></dict>`);
+}
+
+function defaultVerifyManagedBundleSignature(bundle) {
+  const verified = runResult("/usr/bin/codesign", ["--verify", "--deep", "--strict", bundle]);
+  if (verified.status !== 0 || verified.error) throw commandFailure("managed Cursor signature verification", verified);
+  for (const target of cursorProcessBundles(bundle)) {
+    cursorEntitlementsWithDisabledLibraryValidation(readCursorEntitlements(target));
+  }
+}
+
+function defaultVerifyManagedBundle(bundle) {
+  defaultVerifyManagedBundleSignature(bundle);
+  assertCursorProductChecksums(appResources(bundle));
+}
+
+function readManifest(manifestPath) {
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function signingModeCompatible(recorded, wanted) {
+  if (wanted === "local") return recorded === "local";
+  return recorded === wanted;
+}
+
+function manifestMatches(manifest, source, paths, wantedSigningMode) {
+  return manifestRuntimeMatches(manifest, paths, wantedSigningMode)
+    && manifest?.vendor?.bundleIdentifier === source.bundleIdentifier
+    && manifest?.vendor?.teamIdentifier === source.teamIdentifier
+    && manifest?.vendor?.version === source.version
+    && manifest?.vendor?.commit === source.commit
+    && manifest?.vendor?.sourceFingerprint === source.sourceFingerprint;
+}
+
+function manifestRuntimeMatches(manifest, paths, wantedSigningMode) {
+  return manifest?.schemaVersion === CURSOR_RUNTIME_SCHEMA_VERSION
+    && manifest?.tenantId === path.basename(path.dirname(paths.root))
+    && manifest?.profile?.userData === paths.userData
+    && manifest?.profile?.extensions === paths.extensions
+    && manifest?.profile?.home === paths.home
+    && manifest?.applicationName === managedCursorApplicationName(manifest.tenantId)
+    && manifest?.authentication?.kind === "cursor-smoke-test"
+    && manifest?.authentication?.storage === "tenant-only-global-storage"
+    && manifest?.authentication?.processOverride === true
+    && manifest?.patches?.disabledPersonalDataImport === 5
+    && manifest?.patches?.extensionIntegrity === CURSOR_VERIFIED_EXTENSIONS.length
+    && manifest?.patches?.isolatedApplicationName === 1
+    && manifest?.patches?.localMode === CURSOR_LOCAL_MODE_FILES.length
+    && manifest?.patches?.managedProviderOnly === CURSOR_PROVIDER_LOCK_FILES.length
+    && Number.isInteger(manifest?.patches?.productChecksums)
+    && manifest.patches.productChecksums > 0
+    && manifest?.patches?.reasoningTransport === 1
+    && signingModeCompatible(manifest?.signingMode, wantedSigningMode);
+}
+
+function legacyManifestRuntimeMatches(manifest, paths, wantedSigningMode) {
+  return manifest?.schemaVersion === 4
+    && manifest?.tenantId === path.basename(path.dirname(paths.root))
+    && manifest?.profile?.userData === paths.userData
+    && manifest?.profile?.extensions === paths.extensions
+    && manifest?.profile?.home === paths.home
+    && manifest?.applicationName === managedCursorApplicationName(manifest.tenantId)
+    && manifest?.authentication?.kind === "cursor-smoke-test"
+    && manifest?.authentication?.storage === "tenant-only-global-storage"
+    && manifest?.authentication?.processOverride === true
+    && manifest?.patches?.disabledPersonalDataImport === 5
+    && manifest?.patches?.extensionIntegrity === CURSOR_VERIFIED_EXTENSIONS.length
+    && manifest?.patches?.isolatedApplicationName === 1
+    && manifest?.patches?.localMode === CURSOR_LOCAL_MODE_FILES.length
+    && manifest?.patches?.managedProviderOnly === CURSOR_PROVIDER_LOCK_FILES.length
+    && manifest?.patches?.productChecksums === undefined
+    && manifest?.patches?.reasoningTransport === undefined
+    && signingModeCompatible(manifest?.signingMode, wantedSigningMode);
+}
+
+function cursorSourcesMatch(first, second) {
+  return first?.bundleIdentifier === second?.bundleIdentifier
+    && first?.teamIdentifier === second?.teamIdentifier
+    && first?.version === second?.version
+    && first?.commit === second?.commit
+    && first?.sourceFingerprint === second?.sourceFingerprint;
+}
+
+function acquireCursorPrepareLock(runtimeRoot) {
+  const lockPath = path.join(runtimeRoot, CURSOR_PREPARE_LOCK_FILE);
+  if (process.platform !== "darwin") {
+    // Managed Cursor is macOS-only. This process-local fallback exists solely
+    // so the dependency-free unit suite can exercise serialization on the
+    // Linux and Windows CI runners without pretending to provide cross-process
+    // locking on unsupported platforms.
+    if (portableCursorPrepareLocks.has(lockPath)) {
+      throw new Error("another managed Cursor prepare is already running");
+    }
+    const descriptor = fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_RDWR, 0o600);
+    portableCursorPrepareLocks.add(lockPath);
+    return () => {
+      fs.closeSync(descriptor);
+      portableCursorPrepareLocks.delete(lockPath);
+    };
+  }
+
+  let descriptor;
+  try {
+    descriptor = fs.openSync(
+      lockPath,
+      fs.constants.O_CREAT | fs.constants.O_RDWR | fs.constants.O_NONBLOCK | MACOS_O_EXLOCK,
+      0o600,
+    );
+  } catch (error) {
+    if (["EAGAIN", "EWOULDBLOCK"].includes(error?.code)) {
+      throw new Error("another managed Cursor prepare is already running");
+    }
+    throw error;
+  }
+  return () => {
+    try {
+      if (descriptor !== undefined) fs.closeSync(descriptor);
+    } finally {
+      descriptor = undefined;
+    }
+  };
+}
+
+function replaceGeneration(current, staging) {
+  const previous = `${current}.previous-${process.pid}`;
+  fs.rmSync(previous, { recursive: true, force: true });
+  const hadCurrent = fs.existsSync(current);
+  if (hadCurrent) fs.renameSync(current, previous);
+  try {
+    fs.renameSync(staging, current);
+  } catch (error) {
+    if (hadCurrent && !fs.existsSync(current) && fs.existsSync(previous)) fs.renameSync(previous, current);
+    throw error;
+  }
+  fs.rmSync(previous, { recursive: true, force: true });
+}
+
+function recoverPreviousGeneration(paths) {
+  if (fs.existsSync(paths.generation)) return;
+  let candidates = [];
+  try {
+    candidates = fs.readdirSync(paths.runtimeRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith("current.previous-"))
+      .flatMap((entry) => {
+        try {
+          return [{
+            name: entry.name,
+            modifiedAt: fs.statSync(path.join(paths.runtimeRoot, entry.name)).mtimeMs,
+          }];
+        } catch {
+          return [];
+        }
+      })
+      .sort((first, second) => first.modifiedAt - second.modifiedAt || first.name.localeCompare(second.name));
+  } catch {
+    return;
+  }
+  const latest = candidates.at(-1)?.name;
+  if (latest) fs.renameSync(path.join(paths.runtimeRoot, latest), paths.generation);
+}
+
+function sweepCursorGenerationArtifacts(paths) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(paths.runtimeRoot);
+  } catch {
+    return;
+  }
+  const recovered = fs.existsSync(paths.generation);
+  for (const entry of entries) {
+    if ((recovered && entry.startsWith("current.previous-")) || entry.startsWith(".current.tmp-")) {
+      fs.rmSync(path.join(paths.runtimeRoot, entry), { recursive: true, force: true });
+    }
+  }
+}
+
+function prepareManagedCursorGeneration({ tenantId, vendorPath }, dependencies, paths, inspect, wantedSigningMode) {
+  const source = inspect(vendorPath, dependencies);
+  recoverPreviousGeneration(paths);
+  sweepCursorGenerationArtifacts(paths);
+
+  const current = readManifest(paths.manifest);
+  if (manifestMatches(current, source, paths, wantedSigningMode) && fs.existsSync(paths.bundle)) {
+    try {
+      (dependencies.verifyManagedBundle || defaultVerifyManagedBundle)(paths.bundle);
+      return { updated: false, manifest: current, paths, source };
+    } catch {
+      // A corrupted or incompletely signed managed copy is rebuilt from the
+      // still-verified vendor source below. Personal Cursor state is unrelated.
+    }
+  }
+
+  const staging = path.join(paths.runtimeRoot, `.current.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`);
+  const stagingBundle = path.join(staging, "Cursor.app");
+  fs.rmSync(staging, { recursive: true, force: true });
+  fs.mkdirSync(staging, { recursive: true, mode: 0o700 });
+  try {
+    (dependencies.cloneBundle || defaultCloneBundle)(vendorPath, stagingBundle);
+    const clonedSource = inspect(stagingBundle, dependencies);
+    const refreshedSource = inspect(vendorPath, dependencies);
+    if (!cursorSourcesMatch(source, clonedSource) || !cursorSourcesMatch(source, refreshedSource)) {
+      throw new Error("Cursor.app changed while its managed copy was being prepared; retry after the vendor update finishes");
+    }
+    const applicationName = managedCursorApplicationName(tenantId);
+    const patches = patchCursorBundle(stagingBundle, { applicationName });
+    const signingMode = (dependencies.signManagedBundle || defaultSignManagedBundle)(stagingBundle) || "adhoc";
+    (dependencies.verifyManagedBundle || defaultVerifyManagedBundle)(stagingBundle);
+    const manifest = {
+      schemaVersion: CURSOR_RUNTIME_SCHEMA_VERSION,
+      tenantId: normalizeTenantId(tenantId),
+      applicationName,
+      authentication: {
+        kind: "cursor-smoke-test",
+        storage: "tenant-only-global-storage",
+        processOverride: true,
+      },
+      vendor: {
+        path: vendorPath,
+        bundleIdentifier: source.bundleIdentifier,
+        teamIdentifier: source.teamIdentifier,
+        version: source.version,
+        commit: source.commit,
+        sourceFingerprint: source.sourceFingerprint,
+      },
+      profile: {
+        home: paths.home,
+        userData: paths.userData,
+        extensions: paths.extensions,
+      },
+      patches,
+      signingMode,
+      updatePolicy: "mirror-compatible-installed-stable-build",
+    };
+    if (!manifestMatches(manifest, source, paths, wantedSigningMode)) {
+      throw new Error("generated managed Cursor manifest did not satisfy the reuse contract");
+    }
+    fs.writeFileSync(path.join(staging, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    replaceGeneration(paths.generation, staging);
+    return { updated: true, manifest, paths, source };
+  } catch (error) {
+    fs.rmSync(staging, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export function prepareManagedCursor(options, dependencies = {}) {
+  const {
+    tenantId,
+    homeDir = os.homedir(),
+    vendorPath = resolveCursorVendorApp(homeDir),
+    appRoot,
+  } = options;
+  if ((dependencies.platform || process.platform) !== "darwin") {
+    throw new Error("the managed Cursor experiment currently supports macOS only");
+  }
+  const inspect = dependencies.inspectCursorVendorApp || inspectCursorVendorApp;
+  const paths = cursorManagedPaths(homeDir, tenantId, { appRoot });
+  const wantedSigningMode = dependencies.desiredSigningMode?.() || desiredSigningMode();
+  fs.mkdirSync(paths.runtimeRoot, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(paths.home, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(paths.userData, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(paths.extensions, { recursive: true, mode: 0o700 });
+  const releasePrepareLock = acquireCursorPrepareLock(paths.runtimeRoot);
+  try {
+    return prepareManagedCursorGeneration(
+      { tenantId, vendorPath },
+      dependencies,
+      paths,
+      inspect,
+      wantedSigningMode,
+    );
+  } finally {
+    releasePrepareLock();
+  }
+}
+
+function upgradePreparedManagedCursorGeneration(manifest, dependencies, paths, wantedSigningMode) {
+  const verifyLegacy = dependencies.verifyLegacyManagedBundle
+    || dependencies.verifyManagedBundle
+    || defaultVerifyManagedBundleSignature;
+  verifyLegacy(paths.bundle);
+  const staging = path.join(paths.runtimeRoot, `.current.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`);
+  const stagingBundle = path.join(staging, "Cursor.app");
+  fs.rmSync(staging, { recursive: true, force: true });
+  fs.mkdirSync(staging, { recursive: true, mode: 0o700 });
+  try {
+    (dependencies.cloneBundle || defaultCloneBundle)(paths.bundle, stagingBundle);
+    const patches = {
+      ...manifest.patches,
+      reasoningTransport: patchCursorReasoningTransport(appResources(stagingBundle)),
+    };
+    patches.productChecksums = patchCursorProductChecksums(appResources(stagingBundle));
+    const signingMode = (dependencies.signManagedBundle || defaultSignManagedBundle)(stagingBundle) || "adhoc";
+    (dependencies.verifyManagedBundle || defaultVerifyManagedBundle)(stagingBundle);
+    const upgraded = {
+      ...manifest,
+      schemaVersion: CURSOR_RUNTIME_SCHEMA_VERSION,
+      patches,
+      signingMode,
+    };
+    if (!manifestRuntimeMatches(upgraded, paths, wantedSigningMode)) {
+      throw new Error("upgraded managed Cursor manifest did not satisfy the reuse contract");
+    }
+    fs.writeFileSync(path.join(staging, "manifest.json"), `${JSON.stringify(upgraded, null, 2)}\n`, { mode: 0o600 });
+    replaceGeneration(paths.generation, staging);
+    return {
+      updated: true,
+      manifest: upgraded,
+      paths,
+      source: upgraded.vendor,
+      reusedWithoutVendorUpdate: true,
+      upgradedPreparedRuntime: true,
+    };
+  } catch (error) {
+    fs.rmSync(staging, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export function reusePreparedManagedCursor(options, dependencies = {}) {
+  const {
+    tenantId,
+    homeDir = os.homedir(),
+    appRoot,
+  } = options;
+  if ((dependencies.platform || process.platform) !== "darwin") {
+    throw new Error("the managed Cursor experiment currently supports macOS only");
+  }
+  const paths = cursorManagedPaths(homeDir, tenantId, { appRoot });
+  const wantedSigningMode = dependencies.desiredSigningMode?.() || desiredSigningMode();
+  if (!fs.statSync(paths.runtimeRoot, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new Error("no verified prepared managed Cursor runtime is available");
+  }
+  const releasePrepareLock = acquireCursorPrepareLock(paths.runtimeRoot);
+  try {
+    recoverPreviousGeneration(paths);
+    sweepCursorGenerationArtifacts(paths);
+    const manifest = readManifest(paths.manifest);
+    if (!fs.existsSync(paths.bundle)) {
+      throw new Error("no verified prepared managed Cursor runtime is available");
+    }
+    if (manifestRuntimeMatches(manifest, paths, wantedSigningMode)) {
+      (dependencies.verifyManagedBundle || defaultVerifyManagedBundle)(paths.bundle);
+      return {
+        updated: false,
+        manifest,
+        paths,
+        source: manifest.vendor,
+        reusedWithoutVendorUpdate: true,
+      };
+    }
+    if (legacyManifestRuntimeMatches(manifest, paths, wantedSigningMode)) {
+      return upgradePreparedManagedCursorGeneration(manifest, dependencies, paths, wantedSigningMode);
+    }
+    throw new Error("no verified prepared managed Cursor runtime is available");
+  } finally {
+    releasePrepareLock();
+  }
+}
+
+function argumentName(argument) {
+  return String(argument).split("=", 1)[0];
+}
+
+export function assertCursorLaunchArguments(argv) {
+  const blocked = argv.find((argument) => ISOLATION_BREAKING_ARGUMENTS.includes(argumentName(argument)));
+  if (blocked) throw new Error(`Cursor argument ${blocked} would bypass the Impel tenant profile`);
+}
+
+export function cursorSmokeAuthToken(now = Date.now()) {
+  const issuedAt = Math.floor(Number(now) / 1_000);
+  if (!Number.isSafeInteger(issuedAt) || issuedAt <= 0) {
+    throw new Error("a valid time is required for Cursor managed authentication");
+  }
+  const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+  return `${encode({ alg: "none", typ: "JWT" })}.${encode({
+    iss: "cursor-smoke-test",
+    sub: "fake-user",
+    aud: ["cursor"],
+    iat: issuedAt,
+    exp: issuedAt + (180 * 24 * 60 * 60),
+    azp: "cursor-smoke-test",
+    scope: "smoke-test",
+  })}.`;
+}
+
+function sqliteString(value) {
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+function parseSQLiteJSONHex(value, fallback, label) {
+  try {
+    const decoded = Buffer.from(String(value || ""), "hex").toString("utf8");
+    return decoded ? JSON.parse(decoded) : fallback;
+  } catch (error) {
+    throw new Error(`managed Cursor ${label} is invalid: ${error?.message || error}`);
+  }
+}
+
+function uniqueStrings(value) {
+  return [...new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [])];
+}
+
+const CURSOR_REASONING_LABELS = Object.freeze({
+  none: "None",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra High",
+  max: "Max",
+  ultra: "Ultra",
+});
+
+function cursorReasoningControls(model, capabilities, displayName) {
+  const rawLevels = capabilities.reasoning_effort;
+  if (rawLevels === undefined) return { parameterDefinitions: [], variants: [] };
+  if (
+    !Array.isArray(rawLevels)
+    || rawLevels.length === 0
+    || rawLevels.some((level) => (
+      typeof level !== "string"
+      || !/^[a-z][a-z0-9_-]{0,31}$/u.test(level)
+    ))
+  ) {
+    throw new Error(`Cursor model ${model.id} contains invalid reasoning effort levels`);
+  }
+  const levels = [...new Set(rawLevels)];
+  const advertisedDefault = capabilities.default_reasoning_effort;
+  if (advertisedDefault !== undefined && !levels.includes(advertisedDefault)) {
+    throw new Error(`Cursor model ${model.id} contains an invalid default reasoning effort`);
+  }
+  const fallbackDefault = model.provider === "claude"
+    ? (levels.includes("high") ? "high" : levels[0])
+    : (levels.includes("medium") ? "medium" : levels[0]);
+  const defaultEffort = advertisedDefault || fallbackDefault;
+  const label = (effort) => CURSOR_REASONING_LABELS[effort]
+    || `${effort.slice(0, 1).toUpperCase()}${effort.slice(1)}`;
+  return {
+    parameterDefinitions: [{
+      id: "reasoning",
+      name: "Reasoning",
+      markdownTooltip: "Controls how much reasoning effort the model uses.",
+      parameterType: {
+        enumParameter: {
+          values: levels.map((effort) => ({ value: effort, displayName: label(effort) })),
+        },
+      },
+      isCycleableByHotkey: true,
+    }],
+    variants: levels.map((effort) => ({
+      parameterValues: [{ id: "reasoning", value: effort }],
+      displayName: `${displayName} ${label(effort)}`,
+      displayNameOutsidePicker: `${displayName} ${label(effort)}`,
+      isMaxMode: false,
+      isDefaultNonMaxConfig: effort === defaultEffort,
+      isDefaultMaxConfig: effort === defaultEffort,
+    })),
+  };
+}
+
+function cursorCatalogProjection(models) {
+  const byId = new Map();
+  for (const entry of Array.isArray(models) ? models : []) {
+    const model = typeof entry === "string" ? { id: entry } : entry;
+    const modelId = model?.id;
+    if (
+      typeof modelId !== "string"
+      || modelId === "default"
+      || modelId.length > 128
+      || !/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u.test(modelId)
+    ) {
+      throw new Error("Cursor model catalog contains an invalid model identifier");
+    }
+    if (!byId.has(modelId)) byId.set(modelId, model);
+  }
+  if (byId.size === 0) throw new Error("Cursor model catalog contains no model identifiers");
+  return [...byId].map(([modelId, model]) => {
+    const capabilities = model?.capabilities && typeof model.capabilities === "object"
+      ? model.capabilities
+      : {};
+    const displayName = typeof model.display_name === "string" && model.display_name.trim()
+      ? model.display_name.trim()
+      : modelId;
+    const reasoningControls = cursorReasoningControls(model, capabilities, displayName);
+    return {
+      defaultOn: true,
+      name: modelId,
+      clientDisplayName: displayName,
+      serverModelName: modelId,
+      inputboxShortModelName: displayName,
+      supportsAgent: true,
+      supportsNonMaxMode: true,
+      supportsThinking: capabilities.supports_reasoning === true,
+      supportsVision: capabilities.supports_vision === true,
+      namedModelSectionIndex: 99,
+      isRecommendedForBackgroundComposer: false,
+      isUserAdded: true,
+      idAliases: [],
+      cloudAgentEffortModes: [],
+      modelPickerBadges: [],
+      parameterDefinitions: reasoningControls.parameterDefinitions,
+      variants: reasoningControls.variants,
+      legacySlugs: [],
+    };
+  });
+}
+
+export function mergeCursorManagedModels(persistentStorage, previousModelIds, models, gatewayUrl) {
+  if (!persistentStorage || typeof persistentStorage !== "object" || Array.isArray(persistentStorage)) {
+    throw new Error("managed Cursor application storage is invalid");
+  }
+  const modelDescriptors = cursorCatalogProjection(models);
+  const current = modelDescriptors.map((model) => model.name);
+  const previous = new Set(uniqueStrings(previousModelIds));
+  const managed = new Set([...previous, ...current]);
+  const existingAISettings = persistentStorage.aiSettings;
+  const aiSettings = existingAISettings && typeof existingAISettings === "object" && !Array.isArray(existingAISettings)
+    ? { ...existingAISettings }
+    : {};
+  const replaceManaged = (value) => uniqueStrings([
+    ...uniqueStrings(value).filter((entry) => !previous.has(entry)),
+    ...current,
+  ]);
+  aiSettings.userAddedModels = replaceManaged(aiSettings.userAddedModels);
+  aiSettings.modelOverrideEnabled = replaceManaged(aiSettings.modelOverrideEnabled);
+  aiSettings.modelOverrideDisabled = uniqueStrings(aiSettings.modelOverrideDisabled)
+    .filter((entry) => !managed.has(entry));
+  const retainedModels = (Array.isArray(persistentStorage.availableDefaultModels2)
+    ? persistentStorage.availableDefaultModels2
+    : [])
+    .filter((model) => (
+      model
+      && typeof model === "object"
+      && typeof model.name === "string"
+      && !managed.has(model.name)
+    ));
+  if (!retainedModels.some((model) => model.name === "default")) {
+    retainedModels.unshift({
+      defaultOn: true,
+      name: "default",
+      clientDisplayName: "Auto",
+      inputboxShortModelName: "Auto",
+      supportsAgent: true,
+      isRecommendedForBackgroundComposer: true,
+      idAliases: [],
+      cloudAgentEffortModes: [],
+      modelPickerBadges: [],
+      parameterDefinitions: [],
+      variants: [],
+      legacySlugs: [],
+    });
+  }
+  let managedGatewayUrl;
+  if (gatewayUrl !== undefined) {
+    try {
+      const parsed = new URL(gatewayUrl);
+      if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password) throw new Error();
+      managedGatewayUrl = parsed.toString().replace(/\/$/u, "");
+    } catch {
+      throw new Error("managed Cursor gateway URL is invalid");
+    }
+  }
+  return {
+    persistentStorage: {
+      ...persistentStorage,
+      aiSettings,
+      localProviderModelIds: current,
+      localProviderAgentModelIds: current,
+      availableDefaultModels2: [...retainedModels, ...modelDescriptors],
+      ...(managedGatewayUrl ? {
+        openAIBaseUrl: managedGatewayUrl,
+        useOpenAIKey: true,
+      } : {}),
+    },
+    managedModelIds: current,
+  };
+}
+
+export function ensureCursorManagedModels(userData, models, gatewayUrl, dependencies = {}) {
+  if (typeof userData !== "string" || userData.length === 0 || userData.includes("\0")) {
+    throw new Error("a valid managed Cursor user-data directory is required");
+  }
+  const globalStorage = path.join(userData, "User", "globalStorage");
+  const database = path.join(globalStorage, "state.vscdb");
+  fs.mkdirSync(globalStorage, { recursive: true, mode: 0o700 });
+  const readSQL = [
+    "PRAGMA busy_timeout=5000;",
+    "CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);",
+    `SELECT hex(CAST(COALESCE((SELECT value FROM ItemTable WHERE key=${sqliteString(CURSOR_REACTIVE_STORAGE_KEY)}),'{}') AS BLOB));`,
+    `SELECT hex(CAST(COALESCE((SELECT value FROM ItemTable WHERE key=${sqliteString(CURSOR_MANAGED_MODELS_KEY)}),'[]') AS BLOB));`,
+  ].join("");
+  const readResult = dependencies.querySQLite
+    ? dependencies.querySQLite(database, readSQL)
+    : spawnSync("/usr/bin/sqlite3", ["-batch", "-noheader", database, readSQL], { encoding: "utf8" });
+  if (readResult?.status !== 0 || readResult?.error) {
+    const detail = readResult?.error?.message || String(readResult?.stderr || "").trim() || "unknown sqlite error";
+    throw new Error(`could not read managed Cursor models: ${detail}`);
+  }
+  const outputLines = String(readResult.stdout || "").trimEnd().split(/\r?\n/u);
+  const [storageHex = "", previousHex = ""] = outputLines.slice(-2);
+  const persistentStorage = parseSQLiteJSONHex(storageHex, {}, "application storage");
+  const previousModelIds = parseSQLiteJSONHex(previousHex, [], "model marker");
+  const merged = mergeCursorManagedModels(persistentStorage, previousModelIds, models, gatewayUrl);
+  const writeSQL = [
+    "PRAGMA busy_timeout=5000;",
+    "CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);",
+    "BEGIN IMMEDIATE;",
+    `INSERT OR REPLACE INTO ItemTable (key,value) VALUES (${sqliteString(CURSOR_REACTIVE_STORAGE_KEY)},${sqliteString(JSON.stringify(merged.persistentStorage))});`,
+    `INSERT OR REPLACE INTO ItemTable (key,value) VALUES (${sqliteString(CURSOR_MANAGED_MODELS_KEY)},${sqliteString(JSON.stringify(merged.managedModelIds))});`,
+    `INSERT OR REPLACE INTO ItemTable (key,value) VALUES ('cursorAuth/openAIKey',${sqliteString(CURSOR_MANAGED_GATEWAY_SENTINEL)});`,
+    "COMMIT;",
+  ].join("");
+  const writeResult = dependencies.runSQLite
+    ? dependencies.runSQLite(database, writeSQL)
+    : spawnSync("/usr/bin/sqlite3", [database, writeSQL], { encoding: "utf8" });
+  if (writeResult?.status !== 0 || writeResult?.error) {
+    const detail = writeResult?.error?.message || String(writeResult?.stderr || "").trim() || "unknown sqlite error";
+    throw new Error(`could not initialize managed Cursor models: ${detail}`);
+  }
+  fs.chmodSync(database, 0o600);
+  return { database, modelIds: merged.managedModelIds };
+}
+
+export function ensureCursorManagedAuthentication(userData, dependencies = {}) {
+  if (typeof userData !== "string" || userData.length === 0 || userData.includes("\0")) {
+    throw new Error("a valid managed Cursor user-data directory is required");
+  }
+  const token = cursorSmokeAuthToken((dependencies.now || Date.now)());
+  const globalStorage = path.join(userData, "User", "globalStorage");
+  const database = path.join(globalStorage, "state.vscdb");
+  fs.mkdirSync(globalStorage, { recursive: true, mode: 0o700 });
+  const sql = [
+    "PRAGMA busy_timeout=5000;",
+    "CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);",
+    "BEGIN IMMEDIATE;",
+    `INSERT OR REPLACE INTO ItemTable (key,value) VALUES ('cursorAuth/accessToken',${sqliteString(token)});`,
+    "INSERT OR REPLACE INTO ItemTable (key,value) VALUES ('cursorAuth/refreshToken','fake-refresh-token-for-testing');",
+    "DELETE FROM ItemTable WHERE key IN ('cursorAuth/teamId','autorun.cachedAdminSettings');",
+    "COMMIT;",
+  ].join("");
+  const result = dependencies.runSQLite
+    ? dependencies.runSQLite(database, sql)
+    : spawnSync("/usr/bin/sqlite3", [database, sql], { encoding: "utf8" });
+  if (result?.status !== 0 || result?.error) {
+    const detail = result?.error?.message || String(result?.stderr || "").trim() || "unknown sqlite error";
+    throw new Error(`could not initialize managed Cursor authentication: ${detail}`);
+  }
+  fs.chmodSync(database, 0o600);
+  return { database, token };
+}
+
+export function cursorLaunchSpec({
+  paths,
+  gatewayUrl,
+  credential,
+  tenantId,
+  cursorAuthToken,
+  argv = [],
+  environment = process.env,
+}) {
+  assertCursorLaunchArguments(argv);
+  if (typeof cursorAuthToken !== "string" || !cursorAuthToken.endsWith(".") || cursorAuthToken.split(".").length !== 3) {
+    throw new Error("managed Cursor authentication was not initialized");
+  }
+  if (Buffer.byteLength(paths.userData) + CURSOR_IPC_SOCKET_SUFFIX_RESERVE > CURSOR_IPC_SOCKET_PATH_LIMIT) {
+    throw new Error(`managed Cursor user-data path is too long for its macOS IPC socket: ${paths.userData}`);
+  }
+  const env = { ...environment };
+  for (const key of [...DIRECT_PROVIDER_ENV_KEYS, ...RUNTIME_OVERRIDE_ENV_KEYS]) delete env[key];
+  env.HOME = paths.home;
+  env.XDG_CACHE_HOME = path.join(paths.home, ".cache");
+  env.XDG_CONFIG_HOME = path.join(paths.home, ".config");
+  env.XDG_DATA_HOME = path.join(paths.home, ".local", "share");
+  env.CURSOR_LOCAL_AGENT_BASE_URL = `${String(gatewayUrl).replace(/\/+$/u, "")}/experimental/openai/v1`;
+  env.CURSOR_LOCAL_AGENT_API_KEY = credential;
+  env.IMPEL_TENANT_ID = normalizeTenantId(tenantId);
+  return {
+    command: path.join(paths.bundle, "Contents", "MacOS", "Cursor"),
+    args: [
+      `--user-data-dir=${paths.userData}`,
+      `--extensions-dir=${paths.extensions}`,
+      "--disable-updates",
+      "--use-inmemory-secretstorage",
+      "--skip-welcome",
+      "--skip-onboarding",
+      `--override-cursor-auth-token=${cursorAuthToken}`,
+      "--new-window",
+      ...argv,
+    ],
+    env,
+  };
+}
+
+export function launchManagedCursor(spec, dependencies = {}) {
+  const spawnImpl = dependencies.spawn || spawn;
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(spec.command, spec.args, {
+      cwd: process.cwd(),
+      detached: true,
+      env: spec.env,
+      stdio: "ignore",
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+export function managedCursorStatus(options, dependencies = {}) {
+  const {
+    tenantId,
+    homeDir = os.homedir(),
+    vendorPath = null,
+    appRoot,
+  } = options;
+  const paths = cursorManagedPaths(homeDir, tenantId, { appRoot });
+  let source;
+  let compatibilityError = null;
+  try {
+    const resolvedVendorPath = vendorPath || resolveCursorVendorApp(homeDir);
+    source = (dependencies.inspectCursorVendorApp || inspectCursorVendorApp)(resolvedVendorPath, dependencies);
+  } catch (error) {
+    compatibilityError = error?.message || String(error);
+  }
+  const manifest = readManifest(paths.manifest);
+  const wantedSigningMode = dependencies.desiredSigningMode?.() || desiredSigningMode();
+  let runtimeError = null;
+  let ready = Boolean(source && manifestMatches(manifest, source, paths, wantedSigningMode) && fs.existsSync(paths.bundle));
+  if (ready) {
+    try {
+      (dependencies.verifyManagedBundle || defaultVerifyManagedBundle)(paths.bundle);
+    } catch (error) {
+      ready = false;
+      runtimeError = error?.message || String(error);
+    }
+  }
+  return {
+    ready,
+    compatibleVendor: Boolean(source),
+    compatibilityError,
+    runtimeError,
+    vendor: source || null,
+    manifest,
+    paths,
+  };
+}