scalemax 0.1.41 → 0.1.42

package/dist/commands/configure.d.ts

@@ -1,8 +1,9 @@
 import { ModelInfo } from '../utils/api.js';
-import { ClientId } from '../types/client.js';
+import { ClientId, ConfigureResult } from '../types/client.js';
 export declare function detectAll(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function printDetected(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function clientAllowedForModels(clientId: ClientId, models: ModelInfo[]): boolean;
+export declare function rollbackAfterVerificationFailure(result: ConfigureResult, error: unknown): Promise<never>;
 export declare function configureCommand(opts?: {
     all?: boolean;
     home?: string;

package/dist/commands/configure.js

@@ -4,7 +4,7 @@ import ora from 'ora';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
-import { validateApiKey, isAnthropicModel, isModelRouteAvailable, AUTO_MODEL_ID } from '../utils/api.js';
+import { validateApiKey, isAnthropicModel, isModelRouteAvailable, AUTO_MODEL_ID, probeWorkingModels, pinClaudeAliasBackend, claudeAliasBackendPinTarget } from '../utils/api.js';
 import { homeDir } from '../utils/paths.js';
 import { isExactChatCompletionsModelId } from '../configure/models.js';
 import { isContinueEligibleModelId } from '../configure/continue.js';
@@ -85,14 +85,38 @@ export function clientAllowedForModels(clientId, models) {
         return true;
     return models.some(model => !isAnthropicModel(model));
 }
+export async function rollbackAfterVerificationFailure(result, error) {
+    if (!result.changed)
+        throw error;
+    if (!result.rollback) {
+        throw new Error(`${error instanceof Error ? error.message : String(error)}; exact rollback was unavailable, so the current files were left in place rather than broadly removing the client configuration`);
+    }
+    try {
+        await result.rollback();
+    }
+    catch (rollback) {
+        throw new Error(`${error instanceof Error ? error.message : String(error)}; exact rollback also failed: ${rollback instanceof Error ? rollback.message : String(rollback)}`);
+    }
+    throw error;
+}
 function scopeHint(scope) {
-    if (scope === 'deepseek-v4-flash')
-        return 'DeepSeek V4 Flash only';
-    if (scope === 'glm-5.2')
-        return 'GLM 5.2 only';
-    if (scope === 'auto-api')
-        return 'Auto only';
-    return scope === 'both' ? 'OpenAI + Claude' : scope === 'anthropic' ? 'Claude only' : 'OpenAI only';
+    const labels = {
+        openai: 'OpenAI only',
+        anthropic: 'Claude only',
+        both: 'OpenAI + Claude',
+        gemini: 'Gemini only',
+        grok: 'Grok only',
+        qwen: 'Qwen only',
+        deepseek: 'DeepSeek only',
+        mimo: 'MiMo only',
+        local: 'Local Models',
+        reseller: 'reseller model allowlist',
+        'deepseek-v4-flash': 'DeepSeek V4 Flash only',
+        'glm-5.2': 'GLM 5.2 only',
+        'deepseek-v4-pro': 'DeepSeek V4 Pro only',
+        'auto-api': 'Auto only',
+    };
+    return labels[scope];
 }
 export async function configureCommand(opts = {}) {
     const home = opts.home || homeDir();
@@ -106,6 +130,23 @@ export async function configureCommand(opts = {}) {
         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 selectedBaseUrl = keyInfo.baseUrl || SCALEMAX_BASE_URL;
+    // LIVE-PROBE the key's models with a small request and keep only the ones
+    // that actually answer, so a client is configured with working models and
+    // defaults to a working one. Bounded (concurrency + total time); if nothing
+    // probes clean we KEEP the entitlement-filtered list rather than fail — a
+    // slow/degraded upstream must not leave the user with zero models.
+    try {
+        const probeSpinner = ora('Checking which models respond').start();
+        const probe = await probeWorkingModels({ apiKey, baseUrl: selectedBaseUrl, models: keyInfo.models, providerScope });
+        if (probe.models.length && !probe.fallback) {
+            keyInfo.models = probe.models;
+            probeSpinner.succeed(`${probe.models.length}/${probe.probedCount} models responded`);
+        }
+        else {
+            probeSpinner.warn(probe.warning || 'No model answered the probe in time; using the full authenticated catalog');
+        }
+    }
+    catch { /* probing is best-effort; never blocks setup */ }
     const availableClients = clients.filter(c => clientAllowedForModels(c.id, keyInfo.models));
     console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Clients are filtered against the authenticated model catalog.`));
     const detections = await printDetected(home);
@@ -175,13 +216,7 @@ export async function configureCommand(opts = {}) {
                 }
                 catch (error) {
                     verify.fail(`${client.name} verification failed`);
-                    try {
-                        await client.remove(ctx);
-                    }
-                    catch (rollback) {
-                        throw new Error(`${error instanceof Error ? error.message : String(error)}; rollback also failed: ${rollback instanceof Error ? rollback.message : String(rollback)}`);
-                    }
-                    throw error;
+                    await rollbackAfterVerificationFailure(res, error);
                 }
             }
             successful.add(client.id);
@@ -192,6 +227,21 @@ export async function configureCommand(opts = {}) {
             failures.push(`${client.name}: ${message}`);
         }
     }
+    // Pin the working default as this key's `claude-sonnet-4-6` backend so Claude
+    // Desktop (which always sends that id) routes to a model this key can serve.
+    // Best-effort: an older gateway without the endpoint, or a scope that already
+    // has a fixed default, is skipped silently. Never fails the run.
+    if (successful.size > 0) {
+        const target = claudeAliasBackendPinTarget(keyInfo.models);
+        if (target) {
+            try {
+                const pin = await pinClaudeAliasBackend({ apiKey, baseUrl: selectedBaseUrl, model: target });
+                if (pin.ok && !pin.skipped)
+                    console.log(chalk.dim(`Claude Desktop's claude-sonnet-4-6 now routes to ${target} on this key.`));
+            }
+            catch { /* endpoint absent or transient; ignore */ }
+        }
+    }
     if (opts.promptLaunch !== false && !opts.all && process.stdin.isTTY)
         await maybeLaunchCodex(chosen, successful, selectedBaseUrl);
     if (failures.length)

package/dist/commands/helper-bot.js

@@ -4,6 +4,7 @@ import { createInterface } from 'node:readline/promises';
 import { execa } from 'execa';
 import { clients } from '../clients.js';
 import { helperDocsContext } from './helper-docs.js';
+import { rollbackAfterVerificationFailure } from './configure.js';
 import { createChatCompletion, filterModelsForScope, isAnthropicModel } from '../utils/api.js';
 import { redactApiKey } from '../utils/apiKey.js';
 import { loadApiKey } from '../utils/keyStore.js';
@@ -12,6 +13,7 @@ import { validateApiKey } from '../utils/api.js';
 import { commandExists } from '../utils/exec.js';
 import { installClaudeGithubTools } from '../configure/claude-tools.js';
 import { isExactChatCompletionsModelId } from '../configure/models.js';
+import { isContinueEligibleModelId } from '../configure/continue.js';
 export const SCALEMAX_HELPER_REFUSAL = `I am the official ScaleMax Helper.
 
 I can only assist with installing, configuring, repairing, verifying, and troubleshooting ScaleMax.
@@ -804,8 +806,24 @@ function helperActionTarget(question) {
 function requestedProviderScope(question, target) {
     if (/\bglm[-\s]*5[._\s]*2\b/i.test(question))
         return 'glm-5.2';
-    if (/\bdeepseek(?:[-\s]+v4[-\s]+flash)?\b/i.test(question))
+    if (/\bdeepseek[-\s]+v4[-\s]+pro\b/i.test(question))
+        return 'deepseek-v4-pro';
+    if (/\bdeepseek[-\s]+v4[-\s]+flash\b/i.test(question))
         return 'deepseek-v4-flash';
+    if (/\bauto(?:[-\s]+api)?\b/i.test(question))
+        return 'auto-api';
+    if (/\bdeepseek\b/i.test(question))
+        return 'deepseek';
+    if (/\bgemini\b/i.test(question))
+        return 'gemini';
+    if (/\bgrok\b/i.test(question))
+        return 'grok';
+    if (/\bqwen\b/i.test(question))
+        return 'qwen';
+    if (/\bmimo\b/i.test(question))
+        return 'mimo';
+    if (/\blocal models?\b/i.test(question))
+        return 'local';
     if (/\b(?:both|openai\s*\+\s*claude|claude\s*\+\s*openai)\b/i.test(question))
         return 'both';
     if (/\b(?:claude|anthropic)\b/i.test(question))
@@ -819,25 +837,34 @@ function actionModels(connection, requestedScope) {
         ? connection.modelCatalog
         : (connection.availableModels || []).map(id => ({ id }));
     const entitlement = connection.providerScope || 'both';
-    // Always begin with the key's verified entitlement. Natural-language intent
-    // must never widen an exact-model key into an OpenAI/Claude family key.
+    // The authenticated catalog already includes reseller and extra-family
+    // grants. Validate the primary scope, then narrow only for explicit user
+    // intent; never try to reconstruct effective entitlement client-side.
     const catalog = filterModelsForScope(rawCatalog, entitlement);
-    if (!requestedScope)
+    if (!requestedScope || requestedScope === 'reseller' || requestedScope === 'local')
         return catalog;
-    const exactEntitlement = entitlement === 'deepseek-v4-flash' || entitlement === 'glm-5.2';
-    if (exactEntitlement && requestedScope !== entitlement)
-        return [];
-    if (requestedScope === 'deepseek-v4-flash' || requestedScope === 'glm-5.2') {
-        return requestedScope === entitlement
-            ? catalog.filter(model => model.id.trim().toLowerCase() === requestedScope)
-            : [];
-    }
+    const exactModelByScope = {
+        'deepseek-v4-flash': 'deepseek-v4-flash',
+        'glm-5.2': 'glm-5.2',
+        'deepseek-v4-pro': 'deepseek-v4-pro',
+        'auto-api': 'auto',
+    };
+    const exactModel = exactModelByScope[requestedScope];
+    if (exactModel)
+        return catalog.filter(model => model.id.trim().toLowerCase() === exactModel);
     if (requestedScope === 'both') {
-        return catalog.filter(model => !isExactChatCompletionsModelId(model.id));
+        return catalog.filter(model => isAnthropicModel(model)
+            || String(model.provider || model.owned_by || '').trim().toLowerCase() === 'openai');
+    }
+    if (requestedScope === 'anthropic')
+        return catalog.filter(isAnthropicModel);
+    if (requestedScope === 'openai') {
+        return catalog.filter(model => {
+            const family = String(model.provider || model.owned_by || '').trim().toLowerCase();
+            return family ? family === 'openai' : !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id);
+        });
     }
-    return catalog.filter(model => requestedScope === 'anthropic'
-        ? isAnthropicModel(model)
-        : !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id));
+    return catalog.filter(model => String(model.provider || model.owned_by || '').trim().toLowerCase() === requestedScope);
 }
 function helperClientAllowedForModels(clientId, models) {
     if (!models.length)
@@ -845,7 +872,7 @@ function helperClientAllowedForModels(clientId, models) {
     const crossProtocolClients = new Set(['cursor', 'roo-code', 'cline', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
     const onlyExactChat = models.every(model => isExactChatCompletionsModelId(model.id));
     if (clientId === 'continue')
-        return onlyExactChat;
+        return models.some(model => isContinueEligibleModelId(model.id));
     if (clientId === 'claude')
         return models.some(isAnthropicModel);
     if (clientId === 'codex' && onlyExactChat)
@@ -1000,17 +1027,21 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
             write(`✓ ${client.name} ${verified.message}`);
         }
         catch (error) {
-            if (configured.changed) {
-                write(`→ Verification failed; removing the incomplete ScaleMax-managed ${client.name} configuration…`);
-                await client.remove(ctx).catch(() => undefined);
+            if (configured.changed && configured.rollback) {
+                write(`→ Verification failed; restoring the exact pre-configuration ${client.name} state…`);
             }
-            throw error;
+            await rollbackAfterVerificationFailure(configured, error);
         }
     }
     else {
         detection = await client.detect(ctx);
-        if (!detection.configured)
-            throw new Error(`${client.name} configuration was written but could not be detected afterward.`);
+        if (!detection.configured) {
+            const error = new Error(`${client.name} configuration was written but could not be detected afterward.`);
+            if (configured.changed && configured.rollback) {
+                write(`→ Detection failed; restoring the exact pre-configuration ${client.name} state…`);
+            }
+            await rollbackAfterVerificationFailure(configured, error);
+        }
         write(`✓ ${client.name} configuration detected after write.`);
     }
     const activation = client.id === 'roo-code'

package/dist/commands/helper-docs.js

@@ -14,8 +14,8 @@ export const HELPER_DOC_SECTIONS = [
     {
         id: 'provider-scope',
         title: 'Provider scope and visible models',
-        keywords: ['provider', 'scope', 'openai', 'claude', 'anthropic', 'deepseek', 'both', 'models', 'fable'],
-        content: `A ScaleMax key may be OpenAI only, Claude only, both, or the exact-model DeepSeek V4 Flash entitlement. OpenAI-only keys should configure OpenAI-compatible models only. Claude-only keys should configure Claude-compatible models only. Both-scope keys may configure both model families in clients that can switch profiles. Fable 5 is a Claude-family frontend model through ScaleMax and should only appear for Claude-capable or both-scope keys, not OpenAI-only keys. A DeepSeek V4 Flash key discovers only deepseek-v4-flash; broad OpenAI and both scopes do not inherit that entitlement. The model always uses the OpenAI-compatible /v1/chat/completions route with streaming and max_tokens, never Responses. Tool support is route-dependent: trust capabilities.tools from the authenticated catalog. The official route exposes thinking-mode tools and reasoning_content replay; a fallback route may remain text-only.`
+        keywords: ['provider', 'scope', 'openai', 'claude', 'anthropic', 'gemini', 'grok', 'qwen', 'deepseek', 'mimo', 'local', 'reseller', 'both', 'models', 'fable'],
+        content: `ScaleMax keys may grant an OpenAI, Claude, Gemini, Grok, Qwen, DeepSeek, MiMo, Local Models, combined OpenAI + Claude, exact-model, Auto, or reseller allowlist entitlement. The authenticated /models response is authoritative because it already includes per-key reseller grants and any extra families assigned to a credit key. The CLI must never add models absent from that response or strip models that it returned. Fable 5 is a Claude-family frontend model through ScaleMax. DeepSeek V4 Flash, GLM 5.2, and DeepSeek V4 Pro use /v1/chat/completions rather than Responses; tool support remains route-dependent, so trust capabilities.tools from the authenticated catalog.`
     },
     {
         id: 'roo-code',
@@ -33,7 +33,7 @@ export const HELPER_DOC_SECTIONS = [
         id: 'codex-and-clients',
         title: 'Supported client update flow',
         keywords: ['codex', 'cursor', 'claude code', 'opencode', 'openclaw', 'hermes', 'cherry studio', 'update', 'doctor'],
-        content: `scalemax update detects supported clients and configures them from the stored key. scalemax doctor validates the stored key and performs a minimal ScaleMax request. Supported clients include Codex CLI, Cursor, Roo Code, Continue, TRAE SOLO, Claude Code, OpenCode, OpenClaw, Hermes, Cherry Studio, n8n, and API Code. The CLI obtains models from the authenticated matching /models endpoint rather than a hard-coded list. Recognized helper-bot setup and verification requests are executed by the CLI controller before any model fallback is used.`
+        content: `scalemax update detects supported clients and configures them from the stored key. scalemax doctor validates the stored key and performs a small billable streaming request; configured client verifiers may perform an additional small billable request. Supported clients include Codex CLI, Cursor, Roo Code, Continue, TRAE SOLO, Claude Code, OpenCode, OpenClaw, Hermes, Cherry Studio, n8n, and API Code. The CLI obtains models from the authenticated matching /models endpoint rather than a hard-coded list. Recognized helper-bot setup and verification requests are executed by the CLI controller before any model fallback is used.`
     },
     {
         id: 'claude-github-tools',

package/dist/commands/logout.js

@@ -1,4 +1,12 @@
 import chalk from 'chalk';
+import { KEY_ENV } from '../constants.js';
 import { removeApiKey } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
-export async function logoutCommand(home = homeDir()) { await removeApiKey(home); console.log(chalk.green('✓ ScaleMax API key removed.')); }
+export async function logoutCommand(home = homeDir()) {
+    await removeApiKey(home);
+    if (process.env[KEY_ENV]) {
+        console.log(chalk.yellow(`✓ Stored ScaleMax API key removed. ${KEY_ENV} is still set in the parent environment; a child CLI process cannot unset it. Unset it in your shell to stop using that key.`));
+        return;
+    }
+    console.log(chalk.green('✓ Stored ScaleMax API key removed.'));
+}

package/dist/commands/remove.js

@@ -1,16 +1,15 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { clients } from '../clients.js';
-import { loadApiKey } from '../utils/keyStore.js';
-import { SCALEMAX_BASE_URL } from '../constants.js';
+import { loadApiKey, loadBaseUrl } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
 export async function removeCommand(home = homeDir()) {
-    const apiKey = (await loadApiKey(home)) || '';
+    const [apiKey, baseUrl] = await Promise.all([loadApiKey(home), loadBaseUrl(home)]);
     const failures = [];
     for (const client of clients) {
         const spinner = ora(`Removing ${client.name} ScaleMax config`).start();
         try {
-            const res = await client.remove({ home, platform: process.platform, env: process.env, apiKey, baseUrl: SCALEMAX_BASE_URL });
+            const res = await client.remove({ home, platform: process.platform, env: process.env, apiKey, baseUrl });
             spinner.succeed(`${client.name} ${res.message}`);
         }
         catch (err) {

package/dist/configure/api-code.d.ts

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

package/dist/configure/cherry-studio.d.ts

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

package/dist/configure/claude.d.ts

@@ -1,4 +1,4 @@
-import { ConfigureContext, ConfigureResult } from '../types/client.js';
+import { ConfigureContext, ConfigureResult, RemoveContext } from '../types/client.js';
 export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
-export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function remove(ctx: RemoveContext): Promise<ConfigureResult>;

package/dist/configure/claude.js

@@ -1,13 +1,13 @@
 import fs from 'fs-extra';
 import crypto from 'node:crypto';
 import path from 'node:path';
-import { atomicWrite, backupFile } from '../utils/fs.js';
+import { atomicWrite, backupFile, captureFileSnapshots, restoreFileSnapshots, snapshotRollback } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { writeMergedJsonConfig } from './common.js';
 import { GENERATED_HEADER } from '../constants.js';
 import { redactApiKey } from '../utils/apiKey.js';
 import { anthropicOrigin, fastModel, modelIds, preferredModel, AUTO_MODEL_ID } from './models.js';
-import { removeClientSecret, rollbackClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
+import { removeClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
 const id = 'claude';
 const name = 'Claude Code';
 const discoveryKey = 'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY';
@@ -95,7 +95,9 @@ export async function configure(ctx) {
     const customModel = managedCustomModel(ctx);
     const baseUrl = anthropicOrigin(ctx.baseUrl);
     const apiKeyHelper = helperCommand(ctx.home, ctx.platform);
-    const secret = await writeClientSecret(secretPath(ctx.home), ctx);
+    const credentialFile = secretPath(ctx.home);
+    const snapshots = await captureFileSnapshots([file, credentialFile]);
+    const secret = await writeClientSecret(credentialFile, ctx);
     let result;
     try {
         result = await writeMergedJsonConfig(ctx, id, name, file, existing => {
@@ -165,10 +167,21 @@ export async function configure(ctx) {
         });
     }
     catch (error) {
-        await rollbackClientSecret(secretPath(ctx.home), ctx, secret);
+        try {
+            await restoreFileSnapshots(snapshots, ctx.platform);
+        }
+        catch (rollback) {
+            throw new Error(`${error instanceof Error ? error.message : String(error)}; rollback also failed: ${rollback instanceof Error ? rollback.message : String(rollback)}`);
+        }
         throw error;
     }
-    return { ...result, changed: result.changed || secret.changed, message: `configured Anthropic Messages routing with ${model}, file-backed authentication, and gateway discovery${quick ? `; ${quick} handles background work` : ''}` };
+    const changed = result.changed || secret.changed;
+    return {
+        ...result,
+        changed,
+        message: `configured Anthropic Messages routing with ${model}, file-backed authentication, and gateway discovery${quick ? `; ${quick} handles background work` : ''}`,
+        ...(changed ? { rollback: snapshotRollback(snapshots, ctx.platform) } : {}),
+    };
 }
 export async function verify(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
@@ -222,8 +235,18 @@ export async function remove(ctx) {
         return { id, name, changed: removed, path: file, message: removed ? 'removed orphaned ScaleMax Claude Code credential' : 'no ScaleMax configuration found' };
     }
     const settings = await fs.readJson(file).catch(() => undefined);
-    if (!settings || settings?.scalemax?.managedBy !== 'ScaleMax CLI')
-        return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
+    if (!settings || settings?.scalemax?.managedBy !== 'ScaleMax CLI') {
+        const removed = await removeClientSecret(secretPath(ctx.home), ctx);
+        return {
+            id,
+            name,
+            changed: removed,
+            path: file,
+            message: removed
+                ? 'removed orphaned ScaleMax Claude Code credential; left unmanaged configuration unchanged'
+                : 'left unmanaged configuration unchanged',
+        };
+    }
     const managed = asRecord(settings.scalemax);
     const env = asRecord(settings.env);
     const previous = asRecord(managed.previousEnv);

package/dist/configure/client-secret.d.ts

@@ -1,11 +1,8 @@
-import { ConfigureContext } from '../types/client.js';
+import { ConfigureContext, RemoveContext } from '../types/client.js';
 export declare function writeClientSecret(file: string, ctx: ConfigureContext): Promise<{
     changed: boolean;
     backup?: string;
 }>;
-export declare function rollbackClientSecret(file: string, ctx: ConfigureContext, change: {
-    changed: boolean;
-    backup?: string;
-}): Promise<void>;
 export declare function verifyClientSecret(file: string, ctx: ConfigureContext): Promise<void>;
-export declare function removeClientSecret(file: string, ctx: ConfigureContext): Promise<boolean>;
+/** Dedicated scalemax.key paths are durable ownership markers; current login state is not. */
+export declare function removeClientSecret(file: string, _ctx?: RemoveContext): Promise<boolean>;

package/dist/configure/client-secret.js

@@ -15,16 +15,6 @@ export async function writeClientSecret(file, ctx) {
     await atomicWrite(file, content, 0o600, ctx.platform);
     return { changed: true, backup };
 }
-export async function rollbackClientSecret(file, ctx, change) {
-    if (!change.changed)
-        return;
-    if (change.backup) {
-        const previous = await fs.readFile(change.backup, 'utf8');
-        await atomicWrite(file, previous, 0o600, ctx.platform);
-        return;
-    }
-    await fs.remove(file).catch(() => undefined);
-}
 export async function verifyClientSecret(file, ctx) {
     const content = await fs.readFile(file, 'utf8').catch(() => '');
     if (sanitizeApiKey(content) !== sanitizeApiKey(ctx.apiKey))
@@ -35,13 +25,18 @@ export async function verifyClientSecret(file, ctx) {
             throw new Error(`ScaleMax client credential permissions are ${mode.toString(8)}; expected 600.`);
     }
 }
-export async function removeClientSecret(file, ctx) {
-    if (!(await fs.pathExists(file)))
-        return false;
-    const content = await fs.readFile(file, 'utf8').catch(() => '');
-    if (sanitizeApiKey(content) !== sanitizeApiKey(ctx.apiKey))
+/** Dedicated scalemax.key paths are durable ownership markers; current login state is not. */
+export async function removeClientSecret(file, _ctx) {
+    const stat = await fs.lstat(file).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (!stat)
         return false;
-    await backupFile(file, ctx.home);
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new Error(`Refusing to remove non-regular ScaleMax credential path: ${file}`);
+    }
     await fs.remove(file);
     return true;
 }

package/dist/configure/cline.d.ts

@@ -1,4 +1,4 @@
-import { ConfigureContext, ConfigureResult, DetectContext, InstallContext } from '../types/client.js';
+import { ConfigureContext, ConfigureResult, DetectContext, InstallContext, RemoveContext } from '../types/client.js';
 export interface ClineExtensionSurface {
     path: string;
     version?: string;
@@ -26,4 +26,4 @@ export declare function configure(ctx: ConfigureContext): Promise<ConfigureResul
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function isManagedCliStore(value: unknown): boolean;
 export declare function isManagedExtensionState(globalState: unknown, secrets: unknown): boolean;
-export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function remove(ctx: RemoveContext): Promise<ConfigureResult>;