scalemax 0.1.6 → 0.1.8

package/dist/commands/configure.js

@@ -4,6 +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 } from '../utils/api.js';
 import { homeDir } from '../utils/paths.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
@@ -38,33 +39,49 @@ async function maybeLaunchCodex(chosen, successful) {
     }
     console.log('\nIf Codex asks for authentication,\nit should already be configured to use ScaleMax.\n\nIf you still see the official login screen,\nthe configuration is incomplete or Codex rejected the generated auth/config files.\n');
 }
+function clientAllowedForScope(clientId, scope) {
+    if (scope === 'both')
+        return true;
+    if (clientId === 'claude')
+        return scope === 'anthropic';
+    if (clientId === 'api-code')
+        return true;
+    return scope === 'openai';
+}
+function scopeHint(scope) {
+    return scope === 'both' ? 'OpenAI + Claude' : scope === 'anthropic' ? 'Claude only' : 'OpenAI only';
+}
 export async function configureCommand(opts = {}) {
     const home = opts.home || homeDir();
     const apiKey = await loadApiKey(home);
     if (!apiKey)
         throw new Error('No ScaleMax API key found. Run `scalemax login` first.');
+    const keyInfo = await validateApiKey(apiKey);
+    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.`));
     const detections = await printDetected(home);
     const detectedIds = new Set(detections.filter(d => d.installed).map(d => d.id));
     let chosen;
     if (opts.all)
-        chosen = clients.filter(c => detectedIds.has(c.id)).map(c => c.id);
+        chosen = availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id);
     else {
         const action = await select({ message: 'Configure', options: [
-                ...clients.map((c, idx) => ({ value: c.id, label: `${idx + 1}. ${c.name}${detectedIds.has(c.id) ? '' : ' (not detected)'}` })),
+                ...availableClients.map((c, idx) => ({ value: c.id, label: `${idx + 1}. ${c.name}${detectedIds.has(c.id) ? '' : ' (not detected)'}` })),
                 { value: 'all', label: 'A. Configure ALL detected clients' }
             ] });
         if (isCancel(action)) {
             cancel('Configuration cancelled.');
             return;
         }
-        chosen = action === 'all' ? clients.filter(c => detectedIds.has(c.id)).map(c => c.id) : [action];
+        chosen = action === 'all' ? availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id) : [action];
     }
     if (chosen.length === 0) {
         console.log(chalk.yellow('No detected clients to configure.'));
         return;
     }
     const successful = new Set();
-    for (const client of clients.filter(c => chosen.includes(c.id))) {
+    for (const client of availableClients.filter(c => chosen.includes(c.id))) {
         const baseCtx = { home, platform: process.platform, env: process.env };
         if (client.install) {
             const spinner = ora(`Checking ${client.name}`).start();
@@ -79,7 +96,7 @@ export async function configureCommand(opts = {}) {
         }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL };
+            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL, providerScope };
             const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
             if (client.verify) {

package/dist/commands/doctor.js

@@ -24,7 +24,7 @@ export async function doctorCommand(home = homeDir()) {
             failures++;
         }
         const st = ora('Checking streaming').start();
-        const stream = await testStreaming(key, res.models.find(m => m.id === 'gpt-5.6-terra')?.id || res.models[0]?.id);
+        const stream = await testStreaming(key, res.models.find(m => m.id === 'fable-5')?.id || res.models[0]?.id);
         if (stream.ok)
             st.succeed('Streaming available');
         else {

package/dist/commands/login.js

@@ -5,6 +5,7 @@ import { validateApiKey } from '../utils/api.js';
 import { saveApiKey } from '../utils/keyStore.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { homeDir } from '../utils/paths.js';
+import { sanitizeApiKey } from '../utils/apiKey.js';
 export async function loginCommand(home = homeDir()) {
     intro(chalk.cyan('ScaleMax Login'));
     const key = await password({ message: 'Paste your ScaleMax API Key:', mask: '•', validate(value) { return value.trim().length < 12 ? 'Enter a valid ScaleMax API key.' : undefined; } });
@@ -12,14 +13,15 @@ export async function loginCommand(home = homeDir()) {
         cancel('Login cancelled.');
         return;
     }
+    const sanitizedKey = sanitizeApiKey(key);
     const spinner = ora('Verifying API key').start();
-    const result = await validateApiKey(String(key).trim());
+    const result = await validateApiKey(sanitizedKey);
     if (!result.ok) {
         spinner.fail('Invalid API Key');
         throw new Error(result.error || 'Invalid API Key');
     }
-    await saveApiKey(String(key).trim(), SCALEMAX_BASE_URL, home);
-    spinner.succeed('API Key verified');
+    await saveApiKey(sanitizedKey, SCALEMAX_BASE_URL, home);
+    spinner.succeed(`API Key verified (${result.key?.provider_scope || 'both'} provider scope)`);
     outro(chalk.green('ScaleMax API key saved.'));
-    return String(key).trim();
+    return sanitizedKey;
 }

package/dist/configure/cherry-studio.js

@@ -5,7 +5,7 @@ const id = 'cherry-studio';
 const name = 'Cherry Studio';
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl, { "officialSetup": ["Settings > Model Service / Model Providers", "Provider type: OpenAI or OpenAI Compatible", "API host/base URL: https://api.scalemax.pro/v1", "Add ScaleMax model IDs or fetch from /v1/models"], "recommendedModel": "gpt-5.6-terra" });
+    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl, { "officialSetup": ["Settings > Model Service / Model Providers", "Provider type: OpenAI or OpenAI Compatible", "API host/base URL: https://api.scalemax.pro/v1", "Add ScaleMax model IDs or fetch from /v1/models"], "recommendedModel": "fable-5" });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'setup guide written; enter these values in Cherry Studio model provider settings' };
 }

package/dist/configure/claude.js

@@ -8,7 +8,7 @@ export async function configure(ctx) {
         env: {
             ANTHROPIC_AUTH_TOKEN: ctx.apiKey,
             ANTHROPIC_BASE_URL: ctx.baseUrl,
-            ANTHROPIC_MODEL: 'gpt-5.6-terra'
+            ANTHROPIC_MODEL: 'fable-5'
         },
         scalemax: {
             managedBy: 'ScaleMax CLI',

package/dist/configure/codex.js

@@ -8,9 +8,9 @@ import { commandExists } from '../utils/exec.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
-const model = 'gpt-5.6-terra';
+const model = 'fable-5';
 function codexConfig(baseUrl) {
-    return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\ndisable_response_storage = true\n# Recommended ScaleMax Codex models: gpt-5.6-terra, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex.\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`;
+    return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\ndisable_response_storage = true\n# Recommended ScaleMax Codex models: fable-5, fable-5-ultra, gpt-5.6-luna, gpt-5.6-terra, gpt-5.6-sol, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex.\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`;
 }
 function codexAuth(apiKey) {
     return JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: apiKey }, null, 2) + '\n';

package/dist/configure/opencode.js

@@ -12,6 +12,8 @@ export async function configure(ctx) {
                 name: 'ScaleMax',
                 options: { baseURL: ctx.baseUrl, apiKey: ctx.apiKey },
                 models: {
+                    'fable-5': { name: 'Fable 5' },
+                    'fable-5-ultra': { name: 'Fable 5 Ultra' },
                     'gpt-5.6-luna': { name: 'GPT-5.6 Luna' },
                     'gpt-5.6-terra': { name: 'GPT-5.6 Terra' },
                     'gpt-5.6-sol': { name: 'GPT-5.6 Sol' },

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-luna', 'gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review'];
+    const models = ['fable-5', 'fable-5-ultra', 'gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review'];
     return JSON.stringify({
         models: models.map(model => ({
             title: `ScaleMax ${model}`,

package/dist/configure/trae-solo.js

@@ -5,7 +5,7 @@ const id = 'trae-solo';
 const name = 'TRAE SOLO';
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl, { "officialSetup": ["Settings > Models > Add Model", "API format: OpenAI Chat Completions", "Request URL: https://api.scalemax.pro/v1/chat/completions or base URL https://api.scalemax.pro/v1", "Model ID: gpt-5.6-terra or another ScaleMax model"], "recommendedModel": "gpt-5.6-terra" });
+    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl, { "officialSetup": ["Settings > Models > Add Model", "API format: OpenAI Chat Completions", "Request URL: https://api.scalemax.pro/v1/chat/completions or base URL https://api.scalemax.pro/v1", "Model ID: fable-5 or another ScaleMax model"], "recommendedModel": "fable-5" });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'setup guide written; enter these values in TRAE SOLO custom model settings' };
 }

package/dist/index.js

@@ -31,6 +31,15 @@ function welcome() {
     console.log(chalk.cyan('╚══════════════════════════════╝'));
     console.log('\nThe fastest way to connect every AI coding client.\n');
 }
+async function runInteractiveInstaller() {
+    welcome();
+    await runSystemAudit();
+    const apiKey = await ensureInstallerApiKey(process.env.HOME || process.env.USERPROFILE || process.cwd());
+    if (!apiKey)
+        return;
+    await configureCommand(process.stdin.isTTY ? { promptLaunch: true } : { all: true, promptLaunch: false });
+    outro(chalk.green('ScaleMax is ready.'));
+}
 async function main() {
     if (!isNodeSupported()) {
         console.error(chalk.red(`ScaleMax requires Node.js >=18.17. Current: ${process.versions.node}`));
@@ -41,16 +50,14 @@ async function main() {
     const [, , command] = process.argv;
     try {
         if (!command) {
-            welcome();
-            await runSystemAudit();
-            const apiKey = await ensureInstallerApiKey(process.env.HOME || process.env.USERPROFILE || process.cwd());
-            if (!apiKey)
-                return;
-            await configureCommand({ promptLaunch: true });
-            outro(chalk.green('ScaleMax is ready.'));
+            await runInteractiveInstaller();
             return;
         }
         switch (command) {
+            case 'init':
+            case 'setup':
+                await runInteractiveInstaller();
+                break;
             case 'login':
                 await loginCommand();
                 break;
@@ -79,6 +86,8 @@ async function main() {
 
 Commands:
   scalemax            Interactive installer
+  scalemax init       Interactive installer (alias for no-arg scalemax)
+  scalemax setup      Interactive installer (alias)
   scalemax login      Store or replace API key
   scalemax logout     Remove API key
   scalemax doctor     Run diagnostics

package/dist/types/client.d.ts

@@ -1,4 +1,5 @@
 export type ClientId = 'codex' | 'cursor' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
+export type ProviderScope = 'openai' | 'anthropic' | 'both';
 export interface ClientDefinition {
     id: ClientId;
     name: string;

package/dist/utils/api.d.ts

@@ -1,12 +1,20 @@
+export type ProviderScope = 'openai' | 'anthropic' | 'both';
 export interface ModelInfo {
     id: string;
     object?: string;
     owned_by?: string;
     display_name?: string;
 }
+export interface KeyMetadata {
+    provider_scope: ProviderScope;
+    mode?: string;
+    prefix?: string;
+    label?: string;
+}
 export declare function validateApiKey(apiKey: string): Promise<{
     ok: boolean;
     models: ModelInfo[];
+    key?: KeyMetadata;
     error?: string;
 }>;
 export declare function testStreaming(apiKey: string, model?: string): Promise<{

package/dist/utils/api.js

@@ -1,4 +1,5 @@
 import { SCALEMAX_BASE_URL } from '../constants.js';
+import { sanitizeApiKey } from './apiKey.js';
 async function friendlyError(res) {
     let body = '';
     try {
@@ -22,7 +23,7 @@ async function friendlyError(res) {
 async function request(path, apiKey, init = {}) {
     const headers = new Headers(init.headers);
     if (apiKey)
-        headers.set('Authorization', `Bearer ${apiKey}`);
+        headers.set('Authorization', `Bearer ${sanitizeApiKey(apiKey)}`);
     headers.set('Cache-Control', 'no-cache');
     if (!headers.has('Content-Type') && init.body)
         headers.set('Content-Type', 'application/json');
@@ -30,18 +31,23 @@ async function request(path, apiKey, init = {}) {
 }
 export async function validateApiKey(apiKey) {
     try {
-        const res = await request('/models', apiKey);
+        const authCheck = await request('/usage', apiKey);
+        if (!authCheck.ok)
+            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: false, models: [], error: await friendlyError(res) };
+            return { ok: true, models: [], key: keyMeta, error: await friendlyError(res) };
         const data = await res.json();
-        return { ok: Array.isArray(data.data), models: data.data || [] };
+        return { ok: true, models: Array.isArray(data.data) ? data.data : [], key: keyMeta };
     }
     catch (err) {
         return { ok: false, models: [], error: err instanceof Error ? err.message : String(err) };
     }
 }
 export async function testStreaming(apiKey, model) {
-    const selected = model || 'gpt-5.6-terra';
+    const selected = model || 'fable-5';
     try {
         const res = await request('/chat/completions', apiKey, { method: 'POST', body: JSON.stringify({ model: selected, stream: true, max_tokens: 8, messages: [{ role: 'user', content: 'Say OK' }] }) });
         if (!res.ok)

package/dist/utils/apiKey.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeApiKey(input: unknown): string;

package/dist/utils/apiKey.js

@@ -0,0 +1,8 @@
+const ZERO_WIDTH_RE = /[\u200B-\u200D\uFEFF]/g;
+const ASCII_WHITESPACE_RE = /\s+/g;
+export function sanitizeApiKey(input) {
+    return String(input ?? '')
+        .replace(ZERO_WIDTH_RE, '')
+        .replace(ASCII_WHITESPACE_RE, '')
+        .trim();
+}

package/dist/utils/installerConfig.js

@@ -1,10 +1,11 @@
 import { intro, outro, password, select, confirm, isCancel, cancel } from '@clack/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
-import { SCALEMAX_BASE_URL } from '../constants.js';
+import { KEY_ENV, SCALEMAX_BASE_URL } from '../constants.js';
 import { validateApiKey } from './api.js';
 import { loadApiKey, removeApiKey, saveApiKey } from './keyStore.js';
 import { homeDir } from './paths.js';
+import { sanitizeApiKey } from './apiKey.js';
 export function maskApiKey(apiKey) {
     const trimmed = apiKey.trim();
     if (trimmed.length <= 4)
@@ -17,7 +18,7 @@ export async function promptForValidatedKey(home, message = 'Enter your ScaleMax
         cancel('Installer cancelled.');
         return undefined;
     }
-    const candidate = String(key).trim();
+    const candidate = sanitizeApiKey(key);
     const spinner = ora('Validating API key').start();
     const result = await validateApiKey(candidate);
     if (!result.ok) {
@@ -43,11 +44,18 @@ export async function ensureInstallerApiKey(home = homeDir()) {
     intro(chalk.cyan('ScaleMax Installer'));
     const existing = await loadApiKey(home);
     if (!existing) {
+        if (!process.stdin.isTTY)
+            throw new Error(`No ScaleMax API key found. Set ${KEY_ENV} or run \`scalemax login\` in an interactive terminal.`);
         const key = await promptForValidatedKey(home, 'Enter your ScaleMax API key:');
         if (key)
             outro(chalk.green('ScaleMax configuration saved.'));
         return key;
     }
+    if (!process.stdin.isTTY) {
+        console.log(chalk.green('✓ Existing ScaleMax configuration detected.'));
+        console.log(chalk.green('✓ Non-interactive mode: keeping existing key.'));
+        return existing;
+    }
     console.log(chalk.green('✓ Existing ScaleMax configuration detected.'));
     console.log('\nAPI key:');
     console.log(maskApiKey(existing));

package/dist/utils/keyStore.js

@@ -2,15 +2,16 @@ import fs from 'fs-extra';
 import { KEY_ENV } from '../constants.js';
 import { scaleMaxConfigPath, scaleMaxDir } from './paths.js';
 import { readJson, writeJsonAtomic } from './fs.js';
+import { sanitizeApiKey } from './apiKey.js';
 export async function saveApiKey(apiKey, baseUrl, home) {
     await fs.ensureDir(scaleMaxDir(home), 0o700);
-    await writeJsonAtomic(scaleMaxConfigPath(home), { apiKey, baseUrl, updatedAt: new Date().toISOString() }, 0o600);
+    await writeJsonAtomic(scaleMaxConfigPath(home), { apiKey: sanitizeApiKey(apiKey), baseUrl, updatedAt: new Date().toISOString() }, 0o600);
 }
 export async function loadApiKey(home) {
     if (process.env[KEY_ENV])
-        return process.env[KEY_ENV];
+        return sanitizeApiKey(process.env[KEY_ENV]);
     const cfg = await readJson(scaleMaxConfigPath(home), {});
-    return cfg.apiKey;
+    return cfg.apiKey ? sanitizeApiKey(cfg.apiKey) : undefined;
 }
 export async function removeApiKey(home) {
     await fs.remove(scaleMaxConfigPath(home));

package/package.json

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