scalemax 0.1.42 → 0.1.44

package/dist/commands/configure.js

@@ -115,6 +115,7 @@ function scopeHint(scope) {
         'glm-5.2': 'GLM 5.2 only',
         'deepseek-v4-pro': 'DeepSeek V4 Pro only',
         'auto-api': 'Auto only',
+        voice: 'Voice only',
     };
     return labels[scope];
 }

package/dist/configure/claude.js

@@ -23,6 +23,14 @@ const customModelOptionDescriptionKey = 'ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTI
 const fableModelId = 'fable-5';
 const fableModelName = 'Fable 5';
 const fableModelDescription = 'Fable 5 via ScaleMax';
+// Claude's picker exposes ONE custom model slot (shared with Auto). fable-5 keeps
+// it whenever the key has fable-5, so re-running `update` never silently moves an
+// existing user onto a different model and price; fable-5.1 takes the slot only
+// when it is the Fable model this key can reach. Either id stays callable
+// explicitly (e.g. `/model fable-5.1`).
+const fable51ModelId = 'fable-5.1';
+const fable51ModelName = 'Fable 5.1';
+const fable51ModelDescription = 'Fable 5.1 via ScaleMax';
 const autoModelName = 'Auto';
 const autoModelDescription = 'Auto via ScaleMax';
 const verificationTimeoutMs = 60_000;
@@ -43,6 +51,9 @@ const managedCustomModelValues = new Set([
     fableModelId,
     fableModelName,
     fableModelDescription,
+    fable51ModelId,
+    fable51ModelName,
+    fable51ModelDescription,
     AUTO_MODEL_ID,
     autoModelName,
     autoModelDescription
@@ -57,11 +68,11 @@ function helperCommand(home, platform) {
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+function hasModelId(ctx, ...ids) {
+    return (ctx.models || []).some(model => ids.includes(String(model.id || '').trim().toLowerCase()));
+}
 function hasFableModel(ctx) {
-    return (ctx.models || []).some(model => {
-        const id = String(model.id || '').trim().toLowerCase();
-        return id === fableModelId || id === 'claude-fable-5';
-    });
+    return hasModelId(ctx, fableModelId, 'claude-fable-5');
 }
 function hasAutoModel(ctx) {
     return modelIds(ctx).some(id => id.trim().toLowerCase() === AUTO_MODEL_ID);
@@ -74,6 +85,13 @@ function managedCustomModel(ctx) {
             description: fableModelDescription
         };
     }
+    if (hasModelId(ctx, fable51ModelId)) {
+        return {
+            option: fable51ModelId,
+            name: fable51ModelName,
+            description: fable51ModelDescription
+        };
+    }
     if (hasAutoModel(ctx)) {
         return {
             option: AUTO_MODEL_ID,

package/dist/configure/templates.js

@@ -11,7 +11,7 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
-    const models = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
+    const models = ['gpt-6-astra', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
     return JSON.stringify({
         models: models.map(model => ({
             title: model === 'deepseek-v4-flash' ? 'ScaleMax DeepSeek V4 Flash' : `ScaleMax ${model}`,

package/dist/install/codex.d.ts

@@ -1,5 +1,8 @@
+export declare function parseCodexSemver(text?: string): string | undefined;
+export declare function compareCodexSemver(a: string, b: string): number;
 export declare function isCodexExecutableAvailable(): Promise<boolean>;
 export declare function getCodexVersion(): Promise<string | undefined>;
+export declare function resolveLatestCodexVersion(): Promise<string | undefined>;
 export declare function installCodexWithNpm(): Promise<{
     ok: boolean;
     message: string;

package/dist/install/codex.js

@@ -1,6 +1,27 @@
 import { confirm, isCancel } from '@clack/prompts';
 import { execa } from 'execa';
+import fs from 'node:fs';
+import path from 'node:path';
 import { commandExists } from '../utils/exec.js';
+const PKG = '@openai/codex';
+const NPMJS = 'https://registry.npmjs.org/';
+function npmCmd() { return process.platform === 'win32' ? 'npm.cmd' : 'npm'; }
+function specFor(ver) { return ver ? `${PKG}@${ver}` : `${PKG}@latest`; }
+function installHint(ver) { return `npm install -g ${specFor(ver)} --prefer-online`; }
+export function parseCodexSemver(text) {
+    const m = String(text ?? '').match(/(?<![\d.])(\d+\.\d+\.\d+)(?![\d.])/);
+    return m?.[1];
+}
+export function compareCodexSemver(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(n => parseInt(n, 10) || 0);
+    const pb = b.replace(/^v/, '').split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        const d = (pa[i] || 0) - (pb[i] || 0);
+        if (d)
+            return d;
+    }
+    return 0;
+}
 export async function isCodexExecutableAvailable() { return commandExists('codex'); }
 export async function getCodexVersion() { try {
     return (await execa('codex', ['--version'], { reject: false })).stdout.trim();
@@ -8,32 +29,140 @@ export async function getCodexVersion() { try {
 catch {
     return undefined;
 } }
+async function viewLatest(useNpmjs) {
+    const args = ['view', `${PKG}@latest`, 'version', '--prefer-online'];
+    if (useNpmjs)
+        args.push(`--registry=${NPMJS}`);
+    try {
+        const res = await execa(npmCmd(), args, { reject: false, timeout: 15000 });
+        if (res.exitCode !== 0)
+            return undefined;
+        return parseCodexSemver(res.stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function resolveLatestCodexVersion() {
+    return (await viewLatest(true)) ?? (await viewLatest(false));
+}
+async function npmInstall(spec, registry) {
+    const args = ['install', '-g', spec, '--prefer-online'];
+    if (registry)
+        args.push(`--registry=${registry}`);
+    return execa(npmCmd(), args, { all: true, reject: false, stdio: 'pipe' });
+}
+async function npmGlobalBinDir() {
+    try {
+        const prefix = (await execa(npmCmd(), ['prefix', '-g'], { reject: false })).stdout.trim();
+        if (!prefix)
+            return undefined;
+        return process.platform === 'win32' ? prefix : path.join(prefix, 'bin');
+    }
+    catch {
+        return undefined;
+    }
+}
+function npmGlobalCodexPath(binDir) {
+    return path.join(binDir, process.platform === 'win32' ? 'codex.cmd' : 'codex');
+}
+async function whichCodex() {
+    try {
+        if (process.platform === 'win32') {
+            const res = await execa('where', ['codex'], { reject: false });
+            return res.stdout.trim().split(/\r?\n/)[0] || undefined;
+        }
+        const res = await execa('which', ['codex'], { reject: false });
+        return res.stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function versionAt(bin) {
+    try {
+        return parseCodexSemver((await execa(bin, ['--version'], { reject: false })).stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function inspectNpmCodex() {
+    const binDir = await npmGlobalBinDir();
+    if (!binDir)
+        return {};
+    const bin = npmGlobalCodexPath(binDir);
+    if (!fs.existsSync(bin))
+        return { binDir };
+    return { binDir, bin, version: await versionAt(bin) };
+}
 export async function installCodexWithNpm() {
-    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const args = ['install', '-g', '@openai/codex@latest'];
+    const target = await resolveLatestCodexVersion();
+    const spec = specFor(target);
+    const hint = installHint(target);
     try {
-        const res = await execa(npm, args, { all: true, reject: false, stdio: 'pipe' });
-        if (res.exitCode === 0)
-            return { ok: true, message: 'Codex installed with npm.' };
-        return { ok: false, message: `npm install exited with ${res.exitCode}.`, output: res.all };
+        let res = await npmInstall(spec);
+        let inspected = await inspectNpmCodex();
+        let pathVer = parseCodexSemver(await getCodexVersion());
+        const yielded = inspected.version ?? pathVer;
+        const older = Boolean(target && yielded && compareCodexSemver(yielded, target) < 0);
+        if (res.exitCode !== 0 || older) {
+            const retry = await npmInstall(spec, NPMJS);
+            if (retry.exitCode === 0) {
+                res = retry;
+                inspected = await inspectNpmCodex();
+                pathVer = parseCodexSemver(await getCodexVersion());
+            }
+            else if (res.exitCode !== 0) {
+                return { ok: false, message: `npm install exited with ${retry.exitCode}.`, output: retry.all };
+            }
+        }
+        pathVer = parseCodexSemver(await getCodexVersion());
+        if (target && pathVer && compareCodexSemver(pathVer, target) < 0) {
+            const npmVer = inspected.version;
+            if (inspected.bin && inspected.binDir && npmVer && compareCodexSemver(npmVer, target) >= 0) {
+                const shadowed = (await whichCodex()) || 'codex';
+                return { ok: true, message: `Codex ${npmVer} installed at ${inspected.bin}, but an older Codex (${pathVer}) at ${shadowed} is shadowing it on PATH. Remove the older binary or put ${inspected.binDir} first on PATH.`, output: res.all };
+            }
+        }
+        if (res.exitCode !== 0)
+            return { ok: false, message: `npm install exited with ${res.exitCode}.`, output: res.all };
+        return { ok: true, message: 'Codex installed with npm.', output: res.all };
     }
     catch (err) {
-        return { ok: false, message: `Could not run npm install -g @openai/codex@latest: ${err instanceof Error ? err.message : String(err)}` };
+        return { ok: false, message: `Could not run ${hint}: ${err instanceof Error ? err.message : String(err)}` };
     }
 }
 export async function ensureCodexInstalled(interactive = true) {
-    if (await isCodexExecutableAvailable())
-        return { ok: true, installed: false, message: `Codex detected${(await getCodexVersion()) ? ` (${await getCodexVersion()})` : ''}.` };
+    if (await isCodexExecutableAvailable()) {
+        const raw = await getCodexVersion();
+        const current = parseCodexSemver(raw);
+        const latest = await resolveLatestCodexVersion().catch(() => undefined);
+        if (!latest || !current || compareCodexSemver(current, latest) >= 0) {
+            return { ok: true, installed: false, message: `Codex detected${raw ? ` (${raw})` : ''}.` };
+        }
+        if (!interactive) {
+            return { ok: true, installed: false, message: `Codex detected (${raw ?? current}). Update available: ${latest}. Run ${installHint(latest)} to update.` };
+        }
+        const ans = await confirm({ message: `Codex ${current} is installed; update to latest ${latest}?`, initialValue: true });
+        if (isCancel(ans) || ans === false)
+            return { ok: true, installed: false, message: `Codex detected (${raw ?? current}).` };
+        const res = await installCodexWithNpm();
+        if (!res.ok)
+            return { ok: false, installed: false, message: `${res.message}\nIf this is a permission issue, install Node with nvm/fnm/volta or run: ${installHint(latest)}` };
+        return { ok: true, installed: true, message: res.message.includes('shadowing') ? res.message : 'Codex installed and detected.' };
+    }
     if (!interactive)
         return { ok: false, installed: false, message: 'Codex executable was not found on PATH.' };
-    const ans = await confirm({ message: 'Codex CLI is not installed. Install it now with npm install -g @openai/codex@latest?', initialValue: true });
+    const latest = await resolveLatestCodexVersion().catch(() => undefined);
+    const hint = installHint(latest);
+    const ans = await confirm({ message: `Codex CLI is not installed. Install it now with ${hint}?`, initialValue: true });
     if (isCancel(ans) || ans === false)
         return { ok: false, installed: false, message: 'Codex installation skipped.' };
     const res = await installCodexWithNpm();
     if (!res.ok)
-        return { ok: false, installed: false, message: `${res.message}
-If this is a permission issue, install Node with nvm/fnm/volta or run: npm install -g @openai/codex@latest` };
+        return { ok: false, installed: false, message: `${res.message}\nIf this is a permission issue, install Node with nvm/fnm/volta or run: ${hint}` };
     if (!(await isCodexExecutableAvailable()))
         return { ok: false, installed: true, message: 'Codex install finished but codex is not on PATH. Open a new terminal or refresh PATH, then rerun npx scalemax.' };
-    return { ok: true, installed: true, message: 'Codex installed and detected.' };
+    return { ok: true, installed: true, message: res.message.includes('shadowing') ? res.message : 'Codex installed and detected.' };
 }

package/dist/types/client.d.ts

@@ -1,6 +1,6 @@
 export type ClientId = 'codex' | 'cursor' | 'roo-code' | 'cline' | 'continue' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
 /** Keep this mirror aligned with shared/constants/api-key-scopes.ts. */
-export declare const API_KEY_SCOPE_VALUES: readonly ["openai", "anthropic", "both", "deepseek-v4-flash", "glm-5.2", "deepseek-v4-pro", "auto-api", "reseller", "gemini", "grok", "qwen", "deepseek", "mimo", "local"];
+export declare const API_KEY_SCOPE_VALUES: readonly ["openai", "anthropic", "both", "deepseek-v4-flash", "glm-5.2", "deepseek-v4-pro", "auto-api", "reseller", "gemini", "grok", "qwen", "deepseek", "mimo", "local", "voice"];
 export type ProviderScope = (typeof API_KEY_SCOPE_VALUES)[number];
 export declare function isProviderScope(value: unknown): value is ProviderScope;
 export interface ClientDefinition {

package/dist/types/client.js

@@ -14,6 +14,7 @@ export const API_KEY_SCOPE_VALUES = [
     'deepseek',
     'mimo',
     'local',
+    'voice',
 ];
 export function isProviderScope(value) {
     return typeof value === 'string'

package/dist/utils/api.js

@@ -18,7 +18,9 @@ export const MODEL_PROBE_ENOUGH_WORKING = 8;
 export const MODEL_PROBE_MAX_MODELS = 16;
 // Keep only aliases that are no longer offered. Direct GPT-5.6 Sol is an
 // active Codex model and must remain available to all generated clients.
-export const RETIRED_MODEL_IDS = new Set(['fable-5-ultra', 'gpt-5.6-luna']);
+// gpt-5.6-luna was removed from this list: the API revived it 2026-08-14
+// (shared/constants/retired-models.ts), so hiding it here hid a model on sale.
+export const RETIRED_MODEL_IDS = new Set(['fable-5-ultra']);
 export function isRetiredModelId(id) {
     return RETIRED_MODEL_IDS.has(id.trim());
 }

package/package.json

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