scalemax 0.1.10 → 0.1.11

package/README.md

@@ -98,7 +98,7 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 ## Supported clients
 
-`npx scalemax` now focuses on the supported non-VS-Code client set:
+`npx scalemax` supports this client set:
 
 - Codex
 - Cursor
@@ -112,6 +112,22 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 For clients without a stable official config file, the installer writes a ScaleMax setup guide under `~/.scalemax/` instead of modifying private app storage.
 
+### Cursor BYOK routing on macOS
+
+Cursor can send named models through its own plan-gated router unless its local BYOK runtime is active. When you select Cursor, `npx scalemax`:
+
+1. Fetches the complete authenticated model list from `https://api.scalemax.pro/v1/models`.
+2. Asks before closing Cursor and modifying the application.
+3. Verifies one known semantic patch anchor in each of three Cursor bundles before writing anything.
+4. Stores backups outside `Cursor.app`, records SHA-256 hashes, and rolls back all files if any step fails.
+5. Enables Cursor's local BYOK runtime without hard-coding GPT-5.5.
+6. Stores the ScaleMax key in Cursor's native macOS protected-secret format and sets `useOpenAIKey=true` with `openAIBaseUrl=https://api.scalemax.pro/v1`.
+7. Synchronizes every live ScaleMax model into Cursor's local-provider catalog while preserving the user's currently selected model.
+
+Automatic Cursor patching is currently verified on macOS only. Unknown, partial, or changed Cursor bundle signatures fail closed without modifying the app. Cursor updates can replace the patched bundles; rerun `npx scalemax@latest` after an update. `scalemax remove` restores only bundle versions and protected-state values managed by ScaleMax, and refuses to overwrite files changed afterward.
+
+For explicitly approved non-interactive automation, set `SCALEMAX_CURSOR_PATCH_CONSENT=1`. Without it, non-interactive Cursor modification is skipped safely.
+
 ## Examples
 
 List models:

package/dist/clients.js

@@ -18,7 +18,7 @@ import * as apiCodeDetect from './detect/api-code.js';
 import * as apiCodeConfig from './configure/api-code.js';
 export const clients = [
     { id: 'codex', name: 'Codex', detect: codexDetect.detect, install: codexConfig.install, configure: codexConfig.configure, verify: codexConfig.verify, launch: codexConfig.launch, remove: codexConfig.remove },
-    { id: 'cursor', name: 'Cursor', detect: cursorDetect.detect, configure: cursorConfig.configure, remove: cursorConfig.remove },
+    { id: 'cursor', name: 'Cursor', detect: cursorDetect.detect, configure: cursorConfig.configure, verify: cursorConfig.verify, remove: cursorConfig.remove },
     { id: 'trae-solo', name: 'TRAE SOLO', detect: traeSoloDetect.detect, configure: traeSoloConfig.configure, remove: traeSoloConfig.remove },
     { id: 'claude', name: 'Claude Code', detect: claudeDetect.detect, configure: claudeConfig.configure, remove: claudeConfig.remove },
     { id: 'opencode', name: 'OpenCode', detect: opencodeDetect.detect, configure: opencodeConfig.configure, remove: opencodeConfig.remove },

package/dist/commands/configure.js

@@ -57,6 +57,10 @@ export async function configureCommand(opts = {}) {
     if (!apiKey)
         throw new Error('No ScaleMax API key found. Run `scalemax login` first.');
     const keyInfo = await validateApiKey(apiKey);
+    if (!keyInfo.ok)
+        throw new Error(keyInfo.error || 'ScaleMax API key validation failed.');
+    if (!keyInfo.models.length)
+        throw new Error(keyInfo.error || 'ScaleMax returned no models for this API key. No client configuration was changed.');
     const providerScope = keyInfo.key?.provider_scope || 'both';
     const availableClients = clients.filter(c => clientAllowedForScope(c.id, providerScope));
     console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Incompatible clients are hidden.`));
@@ -82,6 +86,23 @@ export async function configureCommand(opts = {}) {
     }
     const successful = new Set();
     for (const client of availableClients.filter(c => chosen.includes(c.id))) {
+        let allowAppModification = false;
+        if (client.id === 'cursor') {
+            if (process.stdin.isTTY) {
+                const approved = await confirm({
+                    message: 'Cursor BYOK requires closing Cursor and modifying 3 application bundles. ScaleMax will back up every file and can restore managed changes. Continue?',
+                    initialValue: false
+                });
+                if (isCancel(approved) || approved === false) {
+                    console.log(chalk.yellow('Cursor setup skipped.'));
+                    continue;
+                }
+                allowAppModification = true;
+            }
+            else {
+                allowAppModification = process.env.SCALEMAX_CURSOR_PATCH_CONSENT === '1';
+            }
+        }
         const baseCtx = { home, platform: process.platform, env: process.env };
         if (client.install) {
             const spinner = ora(`Checking ${client.name}`).start();
@@ -96,7 +117,7 @@ export async function configureCommand(opts = {}) {
         }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL, providerScope };
+            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL, providerScope, models: keyInfo.models, interactive: Boolean(process.stdin.isTTY), allowAppModification };
             const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
             if (client.verify) {

package/dist/configure/codex.d.ts

@@ -6,6 +6,7 @@ export interface CodexVerificationResult {
     configPath: string;
     authPath: string;
 }
+export declare function mergeCodexConfig(existing: string, baseUrl: string): string;
 export declare function verifyCodexConfiguration(ctx: ConfigureContext): Promise<CodexVerificationResult>;
 export declare function install(ctx: InstallContext): Promise<ConfigureResult>;
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/codex.js

@@ -9,8 +9,33 @@ const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
 const model = 'gpt-5.5';
-function codexConfig(baseUrl) {
-    return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\n# Recommended ScaleMax Codex models: gpt-5.5, gpt-5.6-terra, gpt-5.6-sol, gpt-5.6-luna, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, fable-5, fable-5-ultra.\n# Provider-internal gpt-5.3-codex-spark is routed behind the public gpt-5.3-codex Codex slug.\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+const reasoningEffort = 'medium';
+function scalemaxCodexBlock(baseUrl) {
+    return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n# Recommended ScaleMax Codex models: gpt-5.5, gpt-5.6-terra, gpt-5.6-sol, gpt-5.6-luna, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, fable-5, fable-5-ultra.\n# Provider-internal gpt-5.3-codex-spark is routed behind the public gpt-5.3-codex Codex slug.\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+}
+export function mergeCodexConfig(existing, baseUrl) {
+    const preserved = [];
+    let section = '';
+    let skipScaleMaxProvider = false;
+    for (const raw of existing.split(/\r?\n/)) {
+        const line = raw.trim();
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            skipScaleMaxProvider = section === `model_providers.${provider}`;
+            if (skipScaleMaxProvider)
+                continue;
+        }
+        if (skipScaleMaxProvider)
+            continue;
+        if (!section && /^(model|model_provider|model_reasoning_effort|disable_response_storage)\s*=/.test(line))
+            continue;
+        if (line === `# ${GENERATED_HEADER}`)
+            continue;
+        preserved.push(raw);
+    }
+    const tail = preserved.join('\n').trim();
+    return `${scalemaxCodexBlock(baseUrl)}${tail ? `\n${tail}\n` : ''}`;
 }
 function codexAuth(apiKey) {
     return JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: apiKey }, null, 2) + '\n';
@@ -99,6 +124,8 @@ export async function verifyCodexConfiguration(ctx) {
         errors.push(`Codex model mismatch: expected ${model}`);
     if (toml.model_provider !== provider)
         errors.push(`Codex model_provider mismatch: expected ${provider}`);
+    if (toml.model_reasoning_effort !== reasoningEffort)
+        errors.push(`Codex model_reasoning_effort mismatch: expected ${reasoningEffort}`);
     if (toml[`model_providers.${provider}.base_url`] !== ctx.baseUrl)
         errors.push(`Codex base_url mismatch: expected ${ctx.baseUrl}`);
     if (toml[`model_providers.${provider}.wire_api`] !== 'responses')
@@ -120,7 +147,7 @@ export async function verifyCodexConfiguration(ctx) {
             errors.push(`Cannot stat ${file}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    if (await commandExists('codex')) {
+    if (await commandExists('codex', ctx.env)) {
         try {
             const result = await execa('codex', ['doctor', '--json'], {
                 env: { ...process.env, CODEX_HOME: path.join(ctx.home, '.codex') },
@@ -189,7 +216,8 @@ export async function configure(ctx) {
         if (backup)
             backups.push(backup);
     }
-    await atomicWrite(configPath, codexConfig(ctx.baseUrl), 0o600);
+    const existingConfig = await fs.readFile(configPath, 'utf8').catch(() => '');
+    await atomicWrite(configPath, mergeCodexConfig(existingConfig, ctx.baseUrl), 0o600);
     await atomicWrite(authPath, codexAuth(ctx.apiKey), 0o600);
     if (legacyConfig.endsWith('config.json') && await fs.pathExists(legacyConfig))
         await fs.remove(legacyConfig);

package/dist/configure/cursor-bundle.d.ts

@@ -0,0 +1,36 @@
+export declare const CURSOR_BUNDLE_RELATIVE_PATHS: readonly ["Contents/Resources/app/out/main.js", "Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js", "Contents/Resources/app/out/vs/workbench/workbench.glass.main.js"];
+export type CursorBundleStatus = 'unpatched' | 'patched' | 'unsupported' | 'incomplete';
+export interface CursorBundleInspection {
+    path: string;
+    status: 'unpatched' | 'patched' | 'unsupported';
+    originalMatches: number;
+    patchedMatches: number;
+    sha256: string;
+}
+export interface CursorBundleRecord {
+    path: string;
+    relativePath: string;
+    originalSha256: string;
+    patchedSha256: string;
+    backupPath?: string;
+}
+export interface CursorBundlePatchResult {
+    status: 'patched' | 'already-patched';
+    managed: boolean;
+    records: CursorBundleRecord[];
+    backupRoot?: string;
+}
+export declare function cursorAppPath(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string;
+export declare function cursorBundlePaths(appPath: string): string[];
+export declare function sha256Buffer(value: Buffer | string): string;
+export declare function inspectCursorBundle(file: string): Promise<CursorBundleInspection>;
+export declare function inspectCursorBundles(appPath: string): Promise<{
+    status: CursorBundleStatus;
+    bundles: CursorBundleInspection[];
+}>;
+export declare function patchCursorBundles(appPath: string, home: string, platform: NodeJS.Platform, env: NodeJS.ProcessEnv): Promise<CursorBundlePatchResult>;
+export declare function restoreCursorBundles(records: CursorBundleRecord[]): Promise<boolean>;
+export declare const cursorPatchSignatures: {
+    original: string;
+    patched: string;
+};

package/dist/configure/cursor-bundle.js

@@ -0,0 +1,100 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { atomicWrite } from '../utils/fs.js';
+import { scaleMaxDir, timestamp } from '../utils/paths.js';
+export const CURSOR_BUNDLE_RELATIVE_PATHS = [
+    'Contents/Resources/app/out/main.js',
+    'Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js',
+    'Contents/Resources/app/out/vs/workbench/workbench.glass.main.js'
+];
+const FLAGS_PREFIX = 'enableEmbeddingsModelToggle:!1,enableCPPControlTokenToggle:!1,cursorPredictionOptions:!1,localMode:';
+const ORIGINAL = `${FLAGS_PREFIX}!1`;
+const PATCHED = `${FLAGS_PREFIX}!0`;
+export function cursorAppPath(platform, env) {
+    if (env.SCALEMAX_CURSOR_APP_PATH)
+        return path.resolve(env.SCALEMAX_CURSOR_APP_PATH);
+    if (platform === 'darwin')
+        return '/Applications/Cursor.app';
+    throw new Error(`Automatic Cursor BYOK setup is currently verified on macOS only (${platform} is not modified).`);
+}
+export function cursorBundlePaths(appPath) { return CURSOR_BUNDLE_RELATIVE_PATHS.map(p => path.join(appPath, p)); }
+export function sha256Buffer(value) { return crypto.createHash('sha256').update(value).digest('hex'); }
+function count(text, needle) { let n = 0, from = 0; while ((from = text.indexOf(needle, from)) !== -1) {
+    n++;
+    from += needle.length;
+} return n; }
+export async function inspectCursorBundle(file) {
+    const text = await fs.readFile(file, 'utf8');
+    const originalMatches = count(text, ORIGINAL), patchedMatches = count(text, PATCHED);
+    const status = originalMatches === 1 && patchedMatches === 0 ? 'unpatched' : patchedMatches === 1 && originalMatches === 0 ? 'patched' : 'unsupported';
+    return { path: file, status, originalMatches, patchedMatches, sha256: sha256Buffer(text) };
+}
+export async function inspectCursorBundles(appPath) {
+    const files = cursorBundlePaths(appPath);
+    for (const file of files)
+        if (!(await fs.pathExists(file)))
+            throw new Error(`Cursor bundle is missing: ${file}`);
+    const bundles = await Promise.all(files.map(inspectCursorBundle));
+    if (bundles.every(b => b.status === 'unpatched'))
+        return { status: 'unpatched', bundles };
+    if (bundles.every(b => b.status === 'patched'))
+        return { status: 'patched', bundles };
+    if (bundles.some(b => b.status === 'unsupported'))
+        return { status: 'unsupported', bundles };
+    return { status: 'incomplete', bundles };
+}
+export async function patchCursorBundles(appPath, home, platform, env) {
+    const before = await inspectCursorBundles(appPath);
+    if (before.status === 'patched')
+        return { status: 'already-patched', managed: false, records: before.bundles.map((b, i) => ({ path: b.path, relativePath: CURSOR_BUNDLE_RELATIVE_PATHS[i], originalSha256: '', patchedSha256: b.sha256 })) };
+    if (before.status !== 'unpatched')
+        throw new Error(`Unsupported or partial Cursor bundle state (${before.status}). No files were changed.`);
+    const backupRoot = path.join(scaleMaxDir(home, platform, env), 'cursor', 'backups', timestamp());
+    const records = [];
+    await fs.ensureDir(backupRoot, { mode: 0o700 });
+    try {
+        for (let i = 0; i < before.bundles.length; i++) {
+            const b = before.bundles[i], relativePath = CURSOR_BUNDLE_RELATIVE_PATHS[i], backupPath = path.join(backupRoot, relativePath);
+            await fs.ensureDir(path.dirname(backupPath), { mode: 0o700 });
+            await fs.copy(b.path, backupPath, { overwrite: false, errorOnExist: true, preserveTimestamps: true });
+            const mode = (await fs.stat(b.path)).mode & 0o777;
+            const original = await fs.readFile(b.path, 'utf8'), patched = original.replace(ORIGINAL, PATCHED);
+            if (patched === original)
+                throw new Error(`Cursor patch anchor was not changed in ${b.path}`);
+            await atomicWrite(b.path, patched, mode);
+            records.push({ path: b.path, relativePath, originalSha256: b.sha256, patchedSha256: sha256Buffer(patched), backupPath });
+        }
+        const after = await inspectCursorBundles(appPath);
+        if (after.status !== 'patched' || records.some((r, i) => r.patchedSha256 !== after.bundles[i].sha256))
+            throw new Error('Cursor bundle postcondition failed.');
+        return { status: 'patched', managed: true, records, backupRoot };
+    }
+    catch (error) {
+        for (const r of records.slice().reverse())
+            if (r.backupPath && await fs.pathExists(r.backupPath))
+                await fs.copy(r.backupPath, r.path, { overwrite: true, preserveTimestamps: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function restoreCursorBundles(records) {
+    if (!records.length || records.some(r => !r.backupPath))
+        return false;
+    for (const r of records) {
+        if (!(await fs.pathExists(r.path)) || !(await fs.pathExists(r.backupPath)))
+            throw new Error(`Cursor restore file is missing: ${r.path}`);
+        const current = sha256Buffer(await fs.readFile(r.path));
+        const backup = sha256Buffer(await fs.readFile(r.backupPath));
+        if (current !== r.patchedSha256)
+            throw new Error(`Cursor changed after ScaleMax setup; refusing to overwrite ${r.path}.`);
+        if (backup !== r.originalSha256)
+            throw new Error(`Cursor backup hash mismatch: ${r.backupPath}`);
+    }
+    for (const r of records)
+        await fs.copy(r.backupPath, r.path, { overwrite: true, preserveTimestamps: true });
+    const restored = await Promise.all(records.map(async (r) => sha256Buffer(await fs.readFile(r.path)) === r.originalSha256));
+    if (restored.some(v => !v))
+        throw new Error('Cursor restore verification failed.');
+    return true;
+}
+export const cursorPatchSignatures = { original: ORIGINAL, patched: PATCHED };

package/dist/configure/cursor-state.d.ts

@@ -0,0 +1,19 @@
+import { ModelInfo } from '../utils/api.js';
+export declare const CURSOR_STATE_KEY = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
+export declare const CURSOR_SECRET_KEY = "secret://cursorAuth/openAIKey";
+export interface CursorStateRecord {
+    dbPath: string;
+    backupPath: string;
+    originalState: string;
+    configuredState: string;
+    originalSecret?: string;
+    configuredSecret: string;
+    baseUrl: string;
+    modelIds: string[];
+}
+export declare function cursorStateDbPath(home: string, platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string;
+export declare function normalizeCursorBaseUrl(value: string): string;
+export declare function mergeCursorState(current: Record<string, any>, models: ModelInfo[], baseUrl: string): Record<string, any>;
+export declare function encryptCursorSecret(password: string, apiKey: string): string;
+export declare function configureCursorState(home: string, platform: NodeJS.Platform, env: NodeJS.ProcessEnv, apiKey: string, baseUrl: string, models: ModelInfo[], backupRoot: string): Promise<CursorStateRecord>;
+export declare function restoreCursorState(record: CursorStateRecord): Promise<boolean>;

package/dist/configure/cursor-state.js

@@ -0,0 +1,127 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+export const CURSOR_STATE_KEY = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser';
+export const CURSOR_SECRET_KEY = 'secret://cursorAuth/openAIKey';
+const KEYCHAIN_SERVICE = 'Cursor Safe Storage';
+export function cursorStateDbPath(home, platform, env) {
+    if (env.SCALEMAX_CURSOR_STATE_DB)
+        return path.resolve(env.SCALEMAX_CURSOR_STATE_DB);
+    if (platform !== 'darwin')
+        throw new Error(`Cursor protected-state setup is currently verified on macOS only (${platform} is not modified).`);
+    return path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+}
+export function normalizeCursorBaseUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash)
+        throw new Error('Cursor ScaleMax URL must be a clean HTTPS URL.');
+    url.pathname = url.pathname.replace(/\/+$/, '');
+    if (!url.pathname.endsWith('/v1'))
+        url.pathname = `${url.pathname}/v1`.replace(/\/+/g, '/');
+    return url.toString().replace(/\/$/, '');
+}
+function genericModelEntry(id) { return { name: id, defaultOn: true, parameterDefinitions: [], variants: [], legacySlugs: [], idAliases: [], cloudAgentEffortModes: [], modelPickerBadges: [], supportsAgent: true, tooltipData: { primaryText: '', secondaryText: '', secondaryWarningText: false, icon: '', tertiaryText: '', tertiaryTextUrl: '', markdownContent: 'Discovered from your local provider.' }, supportsThinking: false, supportsImages: false, supportsNonMaxMode: true, clientDisplayName: id, serverModelName: id, supportsPlanMode: true, supportsSandboxing: true, inputboxShortModelName: id, supportsCmdK: false, namedModelSectionIndex: 1, tagline: 'Local provider model' }; }
+function isLocalProviderEntry(value) { return value?.tagline === 'Local provider model' || value?.tooltipData?.markdownContent === 'Discovered from your local provider.'; }
+export function mergeCursorState(current, models, baseUrl) {
+    const ids = [...new Set(models.map(m => String(m?.id || '').trim()).filter(Boolean))];
+    if (!ids.length)
+        throw new Error('ScaleMax returned no models; Cursor was not changed.');
+    const existing = Array.isArray(current.availableDefaultModels2) ? current.availableDefaultModels2 : [];
+    const byId = new Map(existing.map((m) => [String(m?.serverModelName || m?.name || ''), m]));
+    const preserved = existing.filter((m) => !isLocalProviderEntry(m));
+    const local = ids.map(id => byId.get(id) || genericModelEntry(id));
+    return { ...current, useOpenAIKey: true, openAIBaseUrl: normalizeCursorBaseUrl(baseUrl), localProviderModelIds: ids, availableDefaultModels2: [...preserved, ...local] };
+}
+export function encryptCursorSecret(password, apiKey) {
+    const key = crypto.pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1'), iv = Buffer.alloc(16, 0x20), cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
+    const encrypted = Buffer.concat([Buffer.from('v10'), cipher.update(apiKey, 'utf8'), cipher.final()]);
+    return JSON.stringify(encrypted);
+}
+async function sqliteValue(db, key) {
+    const sql = `SELECT hex(value) FROM ItemTable WHERE key='${key.replaceAll("'", "''")}';`;
+    const result = await execa('/usr/bin/sqlite3', [db, sql], { reject: false });
+    if (result.exitCode !== 0)
+        throw new Error('Unable to read Cursor protected state. Close Cursor and retry.');
+    const hex = result.stdout.trim();
+    return hex ? Buffer.from(hex, 'hex').toString('utf8') : undefined;
+}
+function sqlText(value) { return `CAST(X'${Buffer.from(value, 'utf8').toString('hex')}' AS TEXT)`; }
+async function writeRows(db, state, secret) {
+    const secretSql = secret === undefined ? `DELETE FROM ItemTable WHERE key='${CURSOR_SECRET_KEY}';` : `INSERT INTO ItemTable(key,value) VALUES('${CURSOR_SECRET_KEY}',${sqlText(secret)}) ON CONFLICT(key) DO UPDATE SET value=excluded.value;`;
+    const sql = `BEGIN IMMEDIATE; INSERT INTO ItemTable(key,value) VALUES('${CURSOR_STATE_KEY}',${sqlText(state)}) ON CONFLICT(key) DO UPDATE SET value=excluded.value; ${secretSql} COMMIT;`;
+    const result = await execa('/usr/bin/sqlite3', [db], { input: sql, reject: false });
+    if (result.exitCode !== 0)
+        throw new Error('Unable to update Cursor protected state. No API key was printed.');
+}
+async function keychainPassword() {
+    const found = await execa('/usr/bin/security', ['find-generic-password', '-w', '-s', KEYCHAIN_SERVICE], { reject: false });
+    if (found.exitCode === 0 && found.stdout)
+        return found.stdout.trimEnd();
+    const password = crypto.randomBytes(32).toString('base64url');
+    const add = await execa('/usr/bin/security', ['add-generic-password', '-U', '-a', 'Cursor', '-s', KEYCHAIN_SERVICE, '-w', password], { reject: false });
+    if (add.exitCode !== 0)
+        throw new Error('Cursor Safe Storage is unavailable. Launch Cursor once, close it, and retry.');
+    return password;
+}
+export async function configureCursorState(home, platform, env, apiKey, baseUrl, models, backupRoot) {
+    const dbPath = cursorStateDbPath(home, platform, env);
+    if (!(await fs.pathExists(dbPath)))
+        throw new Error('Cursor state database was not found. Launch Cursor once, close it, and retry.');
+    const originalState = await sqliteValue(dbPath, CURSOR_STATE_KEY);
+    if (!originalState)
+        throw new Error('Cursor application state was not initialized. Launch Cursor once, close it, and retry.');
+    let parsed;
+    try {
+        parsed = JSON.parse(originalState);
+    }
+    catch {
+        throw new Error('Cursor application state is not valid JSON. No changes were made.');
+    }
+    const configured = mergeCursorState(parsed, models, baseUrl), configuredState = JSON.stringify(configured);
+    const originalSecret = await sqliteValue(dbPath, CURSOR_SECRET_KEY), configuredSecret = encryptCursorSecret(await keychainPassword(), apiKey);
+    const backupPath = path.join(backupRoot, 'state.vscdb');
+    await fs.ensureDir(path.dirname(backupPath), { mode: 0o700 });
+    await fs.copy(dbPath, backupPath, { overwrite: false, errorOnExist: true });
+    await fs.chmod(backupPath, 0o600).catch(() => undefined);
+    try {
+        await writeRows(dbPath, configuredState, configuredSecret);
+    }
+    catch (error) {
+        await fs.copy(backupPath, dbPath, { overwrite: true });
+        throw error;
+    }
+    const verifyState = await sqliteValue(dbPath, CURSOR_STATE_KEY), verifySecret = await sqliteValue(dbPath, CURSOR_SECRET_KEY);
+    if (verifyState !== configuredState || verifySecret !== configuredSecret) {
+        await fs.copy(backupPath, dbPath, { overwrite: true });
+        throw new Error('Cursor protected-state verification failed; original database restored.');
+    }
+    return { dbPath, backupPath, originalState, configuredState, originalSecret, configuredSecret, baseUrl: normalizeCursorBaseUrl(baseUrl), modelIds: configured.localProviderModelIds };
+}
+export async function restoreCursorState(record) {
+    if (!(await fs.pathExists(record.dbPath)))
+        return false;
+    const currentStateText = await sqliteValue(record.dbPath, CURSOR_STATE_KEY);
+    if (!currentStateText)
+        return false;
+    let current, original, configured;
+    try {
+        current = JSON.parse(currentStateText);
+        original = JSON.parse(record.originalState);
+        configured = JSON.parse(record.configuredState);
+    }
+    catch {
+        return false;
+    }
+    const restoreField = (key) => { if (JSON.stringify(current[key]) === JSON.stringify(configured[key])) {
+        if (Object.prototype.hasOwnProperty.call(original, key))
+            current[key] = original[key];
+        else
+            delete current[key];
+    } };
+    for (const key of ['useOpenAIKey', 'openAIBaseUrl', 'localProviderModelIds', 'availableDefaultModels2'])
+        restoreField(key);
+    const currentSecret = await sqliteValue(record.dbPath, CURSOR_SECRET_KEY), secret = currentSecret === record.configuredSecret ? record.originalSecret : currentSecret;
+    await writeRows(record.dbPath, JSON.stringify(current), secret);
+    return true;
+}

package/dist/configure/cursor.d.ts

@@ -1,3 +1,5 @@
 import { ConfigureContext, ConfigureResult } from '../types/client.js';
+export declare function isCursorRunning(appPath: string): Promise<boolean>;
 export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/cursor.js

@@ -1,13 +1,91 @@
-import { clientConfigPath } from './paths.js';
-import { removeManagedConfig, writeMergedJsonConfig } from './common.js';
-import { editorSettings } from './templates.js';
-const id = 'cursor';
-const name = 'Cursor';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { scaleMaxDir, timestamp } from '../utils/paths.js';
+import { writeJsonAtomic, readJson } from '../utils/fs.js';
+import { cursorAppPath, inspectCursorBundles, patchCursorBundles, restoreCursorBundles } from './cursor-bundle.js';
+import { configureCursorState, restoreCursorState } from './cursor-state.js';
+const id = 'cursor', name = 'Cursor';
+function manifestPath(ctx) { return path.join(scaleMaxDir(ctx.home, ctx.platform, ctx.env), 'cursor', 'manifest.json'); }
+async function cursorVersion(appPath) { try {
+    return (await fs.readJson(path.join(appPath, 'Contents', 'Resources', 'app', 'package.json')))?.version;
+}
+catch {
+    return undefined;
+} }
+export async function isCursorRunning(appPath) { const r = await execa('/usr/bin/pgrep', ['-f', `${appPath}/Contents/MacOS/Cursor`], { reject: false }); return r.exitCode === 0 && Boolean(r.stdout.trim()); }
+async function stopCursor(appPath) { await execa('/usr/bin/osascript', ['-e', 'tell application "Cursor" to quit'], { reject: false }); for (let i = 0; i < 30; i++) {
+    if (!(await isCursorRunning(appPath)))
+        return;
+    await new Promise(r => setTimeout(r, 500));
+} throw new Error('Cursor is still running. Close Cursor completely and rerun `npx scalemax`.'); }
+async function launchCursor(appPath) { await execa('/usr/bin/open', ['-a', appPath], { reject: false }); }
 export async function configure(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return writeMergedJsonConfig(ctx, id, name, file, existing => editorSettings(name, ctx.apiKey, ctx.baseUrl, existing));
+    if (ctx.platform !== 'darwin')
+        return { id, name, changed: false, message: `automatic Cursor BYOK setup is currently verified on macOS only; ${ctx.platform} was not modified` };
+    const appPath = cursorAppPath(ctx.platform, ctx.env);
+    if (!(await fs.pathExists(appPath)))
+        return { id, name, changed: false, path: appPath, message: 'Cursor.app was not found' };
+    const inspection = await inspectCursorBundles(appPath);
+    if (inspection.status === 'unsupported' || inspection.status === 'incomplete')
+        throw new Error(`Unsupported or partial Cursor bundle state (${inspection.status}). No files were changed.`);
+    if (inspection.status === 'unpatched' && !ctx.allowAppModification)
+        throw new Error('Cursor BYOK requires a reviewed three-bundle local-mode patch. Rerun interactively and approve the Cursor modification prompt.');
+    const wasRunning = await isCursorRunning(appPath);
+    if (wasRunning) {
+        if (!ctx.allowAppModification)
+            throw new Error('Close Cursor completely and rerun `npx scalemax`.');
+        await stopCursor(appPath);
+    }
+    const prior = await readJson(manifestPath(ctx), undefined);
+    let patchResult, state;
+    const stateBackupRoot = path.join(scaleMaxDir(ctx.home, ctx.platform, ctx.env), 'cursor', 'backups', timestamp());
+    try {
+        patchResult = await patchCursorBundles(appPath, ctx.home, ctx.platform, ctx.env);
+        const backupRoot = patchResult.backupRoot || stateBackupRoot;
+        await fs.ensureDir(backupRoot, { mode: 0o700 });
+        state = await configureCursorState(ctx.home, ctx.platform, ctx.env, ctx.apiKey, ctx.baseUrl, ctx.models || [], backupRoot);
+        if (prior?.state) {
+            state.originalState = prior.state.originalState;
+            state.originalSecret = prior.state.originalSecret;
+        }
+        const bundles = patchResult.managed ? patchResult.records : (prior?.bundleManaged ? prior.bundles : patchResult.records);
+        const manifest = { schemaVersion: 1, createdAt: new Date().toISOString(), appPath, version: await cursorVersion(appPath), bundleManaged: Boolean(patchResult.managed || prior?.bundleManaged), bundles, state };
+        await writeJsonAtomic(manifestPath(ctx), manifest, 0o600);
+        if (wasRunning)
+            await launchCursor(appPath);
+        return { id, name, changed: true, path: manifestPath(ctx), message: `configured protected BYOK routing with ${state.modelIds.length} live ScaleMax models${patchResult.status === 'already-patched' ? ' (Cursor patch already active)' : ' (Cursor patch backed up)'}` };
+    }
+    catch (error) {
+        if (state)
+            await restoreCursorState(state).catch(() => undefined);
+        if (patchResult?.managed)
+            await restoreCursorBundles(patchResult.records).catch(() => undefined);
+        if (wasRunning)
+            await launchCursor(appPath).catch(() => undefined);
+        throw error;
+    }
+}
+export async function verify(ctx) {
+    if (ctx.platform !== 'darwin')
+        return { id, name, changed: false, message: 'verification is currently available on macOS only' };
+    const appPath = cursorAppPath(ctx.platform, ctx.env), inspection = await inspectCursorBundles(appPath), manifest = await readJson(manifestPath(ctx), undefined);
+    if (inspection.status !== 'patched' || !manifest?.state?.modelIds?.length)
+        throw new Error('Cursor local BYOK patch or protected model state is incomplete.');
+    const live = new Set((ctx.models || []).map(m => m.id)), configured = new Set(manifest.state.modelIds), missing = [...live].filter(x => !configured.has(x));
+    if (missing.length)
+        throw new Error(`Cursor is missing ${missing.length} live ScaleMax model(s). Rerun update.`);
+    return { id, name, changed: false, path: manifestPath(ctx), message: `verified local BYOK patch and ${configured.size} configured model IDs` };
 }
 export async function remove(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return removeManagedConfig(ctx, id, name, file);
+    if (ctx.platform !== 'darwin')
+        return { id, name, changed: false, message: `no managed macOS Cursor configuration on ${ctx.platform}` };
+    const file = manifestPath(ctx), manifest = await readJson(file, undefined);
+    if (!manifest)
+        return { id, name, changed: false, path: file, message: 'no ScaleMax-managed Cursor manifest found' };
+    if (await isCursorRunning(manifest.appPath))
+        throw new Error('Close Cursor completely before removing its ScaleMax configuration.');
+    const stateRestored = await restoreCursorState(manifest.state), bundlesRestored = manifest.bundleManaged ? await restoreCursorBundles(manifest.bundles) : false;
+    await fs.remove(file);
+    return { id, name, changed: stateRestored || bundlesRestored, path: file, message: `removed protected BYOK state${bundlesRestored ? ' and restored original Cursor bundles' : ' (pre-existing external Cursor patch left unchanged)'}` };
 }

package/dist/detect/cursor.js

@@ -1,2 +1,18 @@
-import { detectClient } from './common.js';
-export function detect(ctx) { return detectClient(ctx, 'cursor', 'Cursor'); }
+import path from 'node:path';
+import fs from 'fs-extra';
+import { scaleMaxDir } from '../utils/paths.js';
+import { cursorAppPath, inspectCursorBundles } from '../configure/cursor-bundle.js';
+export async function detect(ctx) {
+    if (ctx.platform !== 'darwin')
+        return { id: 'cursor', name: 'Cursor', installed: false, configured: false, paths: [], reason: `automatic BYOK setup currently supports macOS only (${ctx.platform})` };
+    const appPath = cursorAppPath(ctx.platform, ctx.env), manifest = path.join(scaleMaxDir(ctx.home, ctx.platform, ctx.env), 'cursor', 'manifest.json');
+    if (!(await fs.pathExists(appPath)))
+        return { id: 'cursor', name: 'Cursor', installed: false, configured: false, paths: [appPath], reason: 'Cursor.app not found' };
+    try {
+        const inspection = await inspectCursorBundles(appPath), configured = inspection.status === 'patched' && await fs.pathExists(manifest);
+        return { id: 'cursor', name: 'Cursor', installed: true, configured, paths: [appPath, manifest], reason: `bundle status: ${inspection.status}${configured ? '; ScaleMax protected state configured' : ''}` };
+    }
+    catch (error) {
+        return { id: 'cursor', name: 'Cursor', installed: true, configured: false, paths: [appPath], reason: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/types/client.d.ts

@@ -32,6 +32,14 @@ export interface ConfigureContext extends DetectContext {
     apiKey: string;
     baseUrl: string;
     dryRun?: boolean;
+    interactive?: boolean;
+    allowAppModification?: boolean;
+    models?: Array<{
+        id: string;
+        object?: string;
+        owned_by?: string;
+        display_name?: string;
+    }>;
 }
 export interface ConfigureResult {
     id: ClientId;

package/dist/utils/api.js

@@ -36,10 +36,10 @@ export async function validateApiKey(apiKey) {
             return { ok: false, models: [], error: await friendlyError(authCheck) };
         const usage = await authCheck.json().catch(() => ({}));
         const keyMeta = { provider_scope: usage?.key?.provider_scope || 'both', mode: usage?.key?.mode, prefix: usage?.key?.prefix, label: usage?.key?.label };
-        const res = await request('/models');
-        if (!res.ok)
-            return { ok: true, models: [], key: keyMeta, error: await friendlyError(res) };
-        const data = await res.json();
+        const modelsRes = await request('/models', apiKey);
+        if (!modelsRes.ok)
+            return { ok: true, models: [], key: keyMeta, error: await friendlyError(modelsRes) };
+        const data = await modelsRes.json();
         return { ok: true, models: Array.isArray(data.data) ? data.data : [], key: keyMeta };
     }
     catch (err) {

package/dist/utils/exec.d.ts

@@ -1 +1 @@
-export declare function commandExists(command: string): Promise<boolean>;
+export declare function commandExists(command: string, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/utils/exec.js

@@ -1,9 +1,9 @@
 import { execa } from 'execa';
-export async function commandExists(command) {
+export async function commandExists(command, env = process.env) {
     const checker = process.platform === 'win32' ? 'where' : 'command';
     const args = process.platform === 'win32' ? [command] : ['-v', command];
     try {
-        await execa(checker, args, { shell: process.platform !== 'win32' });
+        await execa(checker, args, { shell: process.platform !== 'win32', env });
         return true;
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {