scalemax 0.1.43 → 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/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/package.json

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