scalemax 0.1.2 → 0.1.4

package/dist/bootstrap.cjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+'use strict';
+function cmp(a,b){a=String(a).replace(/^v/,'').split('.').map(Number);b=String(b).split('.').map(Number);for(var i=0;i<3;i++){var d=(a[i]||0)-(b[i]||0);if(d)return d;}return 0;}
+var min='18.17.0';
+if (cmp(process.versions.node,min)<0) {
+  console.error('ScaleMax requires Node.js >= '+min+'. Current: '+process.versions.node);
+  console.error('Install Node.js LTS, then rerun: npx scalemax@latest');
+  console.error('macOS: brew install node@22 && brew link --overwrite node@22');
+  console.error('Ubuntu/Debian/WSL: curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt-get install -y nodejs');
+  console.error('Fedora: sudo dnf install -y nodejs npm');
+  console.error('Arch: sudo pacman -S --needed nodejs npm');
+  console.error('Windows PowerShell: winget install OpenJS.NodeJS.LTS');
+  process.exit(1);
+}
+import('./index.js').catch(function(err){ console.error(err && err.stack || err); process.exit(1); });

package/dist/clients.js

@@ -17,7 +17,7 @@ import * as vscodeConfig from './configure/vscode.js';
 import * as windsurfDetect from './detect/windsurf.js';
 import * as windsurfConfig from './configure/windsurf.js';
 export const clients = [
-    { id: 'codex', name: 'Codex', detect: codexDetect.detect, configure: codexConfig.configure, remove: codexConfig.remove },
+    { 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: '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

@@ -5,7 +5,6 @@ import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
-import { launchCodex } from '../configure/codex.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
     return Promise.all(clients.map(c => c.detect(ctx)));
@@ -26,13 +25,16 @@ async function maybeLaunchCodex(chosen, successful) {
     if (isCancel(answer) || answer === false)
         return;
     console.log('\nLaunching Codex...\n');
-    const result = await launchCodex();
-    if (result.ok)
-        console.log(chalk.green(`✓ ${result.message}`));
-    else {
-        console.log(chalk.red(`✗ ${result.message}`));
-        if (result.output)
-            console.log(result.output);
+    const codex = clients.find(c => c.id === 'codex');
+    try {
+        const apiKey = await loadApiKey(homeDir());
+        if (!apiKey)
+            throw new Error('No API key found.');
+        const result = await codex?.launch?.({ home: homeDir(), platform: process.platform, env: process.env, apiKey, baseUrl: SCALEMAX_BASE_URL });
+        console.log(chalk.green(`✓ ${result?.message || 'Codex launched.'}`));
+    }
+    catch (err) {
+        console.log(chalk.red(`✗ ${err instanceof Error ? err.message : String(err)}`));
     }
     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');
 }
@@ -63,11 +65,29 @@ export async function configureCommand(opts = {}) {
     }
     const successful = new Set();
     for (const client of clients.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();
+            try {
+                const res = await client.install({ ...baseCtx, interactive: process.stdin.isTTY });
+                spinner.succeed(`${client.name} ${res.message}`);
+            }
+            catch (err) {
+                spinner.fail(`${client.name} install failed: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const res = await client.configure({ home, platform: process.platform, env: process.env, apiKey, baseUrl: SCALEMAX_BASE_URL });
-            successful.add(client.id);
+            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL };
+            const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
+            if (client.verify) {
+                const verify = ora(`Verifying ${client.name}`).start();
+                const v = await client.verify(ctx);
+                verify.succeed(`${client.name} ${v.message}`);
+            }
+            successful.add(client.id);
         }
         catch (err) {
             spinner.fail(`${client.name} failed: ${err instanceof Error ? err.message : String(err)}`);

package/dist/configure/codex.d.ts

@@ -1,4 +1,4 @@
-import { ConfigureContext, ConfigureResult } from '../types/client.js';
+import { ConfigureContext, ConfigureResult, InstallContext } from '../types/client.js';
 export interface CodexVerificationResult {
     ok: boolean;
     warnings: string[];
@@ -7,8 +7,11 @@ export interface CodexVerificationResult {
     authPath: 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>;
 export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
 export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function launch(ctx?: ConfigureContext): Promise<ConfigureResult>;
 export declare function launchCodex(): Promise<{
     ok: boolean;
     message: string;

package/dist/configure/codex.js

@@ -164,6 +164,20 @@ export async function verifyCodexConfiguration(ctx) {
     }
     return { ok: errors.length === 0, warnings, errors, configPath, authPath };
 }
+export async function install(ctx) {
+    const mod = await import('../install/codex.js');
+    const res = await mod.ensureCodexInstalled(ctx.interactive ?? process.stdin.isTTY);
+    if (!res.ok)
+        throw new Error(res.message);
+    return { id, name, changed: res.installed, message: res.message };
+}
+export async function verify(ctx) {
+    const verification = await verifyCodexConfiguration(ctx);
+    if (!verification.ok)
+        throw new Error(verification.errors.join('\n'));
+    const warnings = verification.warnings.length ? ` Warnings: ${verification.warnings.join(' ')}` : '';
+    return { id, name, changed: false, path: verification.configPath, message: `verified.${warnings}` };
+}
 export async function configure(ctx) {
     const configPath = codexConfigPath(ctx.home);
     const authPath = codexAuthPath(ctx.home);
@@ -195,6 +209,12 @@ export async function remove(ctx) {
         messages.push(`legacy config.json: ${await restoreOrRemove(legacyConfig, ctx.home)}`);
     return { id, name, changed: true, path: codexConfigPath(ctx.home), message: messages.join('; ') };
 }
+export async function launch(ctx) {
+    const result = await launchCodex();
+    if (!result.ok)
+        throw new Error(result.output ? `${result.message} ${result.output}` : result.message);
+    return { id, name, changed: false, message: result.message };
+}
 export async function launchCodex() {
     if (!(await commandExists('codex')))
         return { ok: false, message: 'Codex executable was not found on PATH.' };

package/dist/detect/codex.js

@@ -1,2 +1,19 @@
-import { detectClient } from './common.js';
-export function detect(ctx) { return detectClient(ctx, 'codex', 'Codex'); }
+import fs from 'fs-extra';
+import path from 'node:path';
+import { commandExists } from '../utils/exec.js';
+export async function detect(ctx) {
+    const codexDir = path.join(ctx.home, '.codex');
+    const config = path.join(codexDir, 'config.toml');
+    const auth = path.join(codexDir, 'auth.json');
+    const paths = [];
+    const executable = await commandExists('codex');
+    if (executable)
+        paths.push('command:codex');
+    if (await fs.pathExists(config))
+        paths.push(config);
+    if (await fs.pathExists(auth))
+        paths.push(auth);
+    if (!paths.length && await fs.pathExists(codexDir))
+        paths.push(codexDir);
+    return { id: 'codex', name: 'Codex', installed: executable, reason: executable ? undefined : (paths.length ? 'configuration exists but codex executable is missing' : 'not detected'), paths, executable, configured: await fs.pathExists(config) && await fs.pathExists(auth), installable: true };
+}

package/dist/index.js

@@ -12,6 +12,8 @@ import { modelsCommand } from './commands/models.js';
 import { updateCommand } from './commands/update.js';
 import { removeCommand } from './commands/remove.js';
 import { ensureInstallerApiKey } from './utils/installerConfig.js';
+import { isNodeSupported, nodeUpgradeHint } from './utils/runtime.js';
+import { runSystemAudit } from './utils/systemAudit.js';
 function packageVersion() {
     const here = path.dirname(fileURLToPath(import.meta.url));
     const candidates = [path.join(here, '..', 'package.json'), path.join(here, 'package.json')];
@@ -30,14 +32,21 @@ function welcome() {
     console.log('\nThe fastest way to connect every AI coding client.\n');
 }
 async function main() {
+    if (!isNodeSupported()) {
+        console.error(chalk.red(`ScaleMax requires Node.js >=18.17. Current: ${process.versions.node}`));
+        console.error(nodeUpgradeHint());
+        process.exitCode = 1;
+        return;
+    }
     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();
+            await configureCommand({ promptLaunch: true });
             outro(chalk.green('ScaleMax is ready.'));
             return;
         }

package/dist/install/codex.d.ts

@@ -0,0 +1,12 @@
+export declare function isCodexExecutableAvailable(): Promise<boolean>;
+export declare function getCodexVersion(): Promise<string | undefined>;
+export declare function installCodexWithNpm(): Promise<{
+    ok: boolean;
+    message: string;
+    output?: string;
+}>;
+export declare function ensureCodexInstalled(interactive?: boolean): Promise<{
+    ok: boolean;
+    installed: boolean;
+    message: string;
+}>;

package/dist/install/codex.js

@@ -0,0 +1,39 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { execa } from 'execa';
+import { commandExists } from '../utils/exec.js';
+export async function isCodexExecutableAvailable() { return commandExists('codex'); }
+export async function getCodexVersion() { try {
+    return (await execa('codex', ['--version'], { reject: false })).stdout.trim();
+}
+catch {
+    return undefined;
+} }
+export async function installCodexWithNpm() {
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const args = ['install', '-g', '@openai/codex@latest'];
+    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 };
+    }
+    catch (err) {
+        return { ok: false, message: `Could not run npm install -g @openai/codex@latest: ${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 (!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 });
+    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` };
+    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.' };
+}

package/dist/types/client.d.ts

@@ -3,7 +3,10 @@ export interface ClientDefinition {
     id: ClientId;
     name: string;
     detect: (ctx: DetectContext) => Promise<DetectionResult>;
+    install?: (ctx: InstallContext) => Promise<ConfigureResult>;
     configure: (ctx: ConfigureContext) => Promise<ConfigureResult>;
+    verify?: (ctx: ConfigureContext) => Promise<ConfigureResult>;
+    launch?: (ctx: ConfigureContext) => Promise<ConfigureResult>;
     remove: (ctx: ConfigureContext) => Promise<ConfigureResult>;
 }
 export interface DetectContext {
@@ -17,6 +20,12 @@ export interface DetectionResult {
     installed: boolean;
     reason?: string;
     paths: string[];
+    executable?: boolean;
+    configured?: boolean;
+    installable?: boolean;
+}
+export interface InstallContext extends DetectContext {
+    interactive?: boolean;
 }
 export interface ConfigureContext extends DetectContext {
     apiKey: string;

package/dist/utils/runtime.d.ts

@@ -0,0 +1,24 @@
+export declare const MIN_NODE = "18.17.0";
+export declare const RECOMMENDED_NODE = "22";
+export type OsFamily = 'macos' | 'ubuntu' | 'debian' | 'fedora' | 'arch' | 'windows' | 'wsl' | 'linux' | 'unknown';
+export type RuntimeAudit = {
+    os: OsFamily;
+    platform: NodeJS.Platform;
+    arch: string;
+    isWsl: boolean;
+    nodeVersion: string;
+    nodeOk: boolean;
+    npmVersion?: string;
+    npmOk: boolean;
+    pathEntries: string[];
+    packageManager?: string;
+    installCommand?: string;
+};
+export declare function compareSemver(a: string, b: string): number;
+export declare function isNodeSupported(version?: string): boolean;
+export declare function npmVersion(): Promise<string | undefined>;
+export declare function detectOsFamily(): Promise<OsFamily>;
+export declare function runtimeAudit(): Promise<RuntimeAudit>;
+export declare function nodeInstallCommand(osFamily: OsFamily, pm?: string): string | undefined;
+export declare function nodeUpgradeHint(): string;
+export declare function runtimeReport(): Promise<string>;

package/dist/utils/runtime.js

@@ -0,0 +1,72 @@
+import os from 'node:os';
+import { execa } from 'execa';
+import { commandExists } from './exec.js';
+export const MIN_NODE = '18.17.0';
+export const RECOMMENDED_NODE = '22';
+export function compareSemver(a, b) { const pa = a.replace(/^v/, '').split('.').map(Number), pb = b.replace(/^v/, '').split('.').map(Number); for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d)
+        return d;
+} return 0; }
+export function isNodeSupported(version = process.versions.node) { return compareSemver(version, MIN_NODE) >= 0; }
+export async function npmVersion() { try {
+    return (await execa(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['-v'])).stdout.trim();
+}
+catch {
+    return undefined;
+} }
+async function detectLinuxId() {
+    try {
+        const txt = await import('node:fs/promises').then(fs => fs.readFile('/etc/os-release', 'utf8'));
+        return (txt.match(/^ID=(.+)$/m)?.[1] || '').replace(/['"]/g, '').toLowerCase();
+    }
+    catch {
+        return '';
+    }
+}
+export async function detectOsFamily() {
+    const release = os.release().toLowerCase();
+    const isWsl = process.platform === 'linux' && (release.includes('microsoft') || release.includes('wsl'));
+    if (isWsl)
+        return 'wsl';
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'win32')
+        return 'windows';
+    if (process.platform === 'linux') {
+        const id = await detectLinuxId();
+        if (['ubuntu', 'debian', 'fedora', 'arch'].includes(id))
+            return id;
+        return 'linux';
+    }
+    return 'unknown';
+}
+async function firstCommand(commands) { for (const c of commands)
+    if (await commandExists(c))
+        return c; return undefined; }
+export async function runtimeAudit() {
+    const osFamily = await detectOsFamily();
+    const npm = await npmVersion();
+    const pathEntries = (process.env.PATH || '').split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+    const packageManager = await firstCommand(process.platform === 'win32' ? ['winget', 'choco', 'scoop'] : ['brew', 'apt-get', 'dnf', 'pacman', 'npm']);
+    return { os: osFamily, platform: process.platform, arch: process.arch, isWsl: osFamily === 'wsl', nodeVersion: process.versions.node, nodeOk: isNodeSupported(), npmVersion: npm, npmOk: Boolean(npm), pathEntries, packageManager, installCommand: nodeInstallCommand(osFamily, packageManager) };
+}
+export function nodeInstallCommand(osFamily, pm) {
+    if (osFamily === 'macos' && pm === 'brew')
+        return 'brew install node@22 && brew link --overwrite node@22';
+    if ((osFamily === 'ubuntu' || osFamily === 'debian' || osFamily === 'wsl') && pm === 'apt-get')
+        return 'curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt-get install -y nodejs';
+    if (osFamily === 'fedora' && pm === 'dnf')
+        return 'sudo dnf install -y nodejs npm';
+    if (osFamily === 'arch' && pm === 'pacman')
+        return 'sudo pacman -S --needed nodejs npm';
+    if (osFamily === 'windows' && pm === 'winget')
+        return 'winget install OpenJS.NodeJS.LTS';
+    if (osFamily === 'windows' && pm === 'choco')
+        return 'choco install nodejs-lts -y';
+    if (osFamily === 'windows' && pm === 'scoop')
+        return 'scoop install nodejs-lts';
+    return undefined;
+}
+export function nodeUpgradeHint() { return ['Install Node.js LTS, then rerun: npx scalemax@latest', 'macOS Homebrew: brew install node@22 && brew link --overwrite node@22', 'Ubuntu/Debian/WSL: curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt-get install -y nodejs', 'Fedora: sudo dnf install -y nodejs npm', 'Arch: sudo pacman -S --needed nodejs npm', 'Windows PowerShell: winget install OpenJS.NodeJS.LTS'].join('\n'); }
+export async function runtimeReport() { const a = await runtimeAudit(); return `OS ${a.os} ${a.arch} · Node ${a.nodeVersion} ${a.nodeOk ? '✓' : '✗'} (required >=${MIN_NODE}) · npm ${a.npmVersion || 'not found'} ${a.npmOk ? '✓' : '✗'} · PATH entries ${a.pathEntries.length}`; }

package/dist/utils/systemAudit.d.ts

@@ -0,0 +1 @@
+export declare function runSystemAudit(): Promise<void>;

package/dist/utils/systemAudit.js

@@ -0,0 +1,32 @@
+import { confirm, isCancel } from '@clack/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { execa } from 'execa';
+import { runtimeAudit, nodeUpgradeHint } from './runtime.js';
+function check(label, ok, value) { console.log(`${ok ? chalk.green('✓') : chalk.red('✗')} ${label} ${value}`); }
+async function runCommand(command) { const res = await execa(command, { shell: true, stdio: 'inherit', reject: false }); return res.exitCode === 0; }
+export async function runSystemAudit() {
+    const spin = ora('Checking system').start();
+    const audit = await runtimeAudit();
+    spin.stop();
+    check('Operating system', true, `${audit.os}${audit.isWsl ? ' (WSL)' : ''}`);
+    check('Architecture', true, audit.arch);
+    check('Node.js', audit.nodeOk, `v${audit.nodeVersion}`);
+    check('npm', audit.npmOk, audit.npmVersion ? `v${audit.npmVersion}` : 'not found');
+    check('PATH', audit.pathEntries.length > 0, `${audit.pathEntries.length} entries`);
+    if (audit.nodeOk && audit.npmOk)
+        return;
+    console.log(chalk.yellow('\nScaleMax needs a supported Node.js/npm runtime before continuing.'));
+    if (audit.installCommand) {
+        console.log(`\nRecommended command:\n${chalk.cyan(audit.installCommand)}\n`);
+        const ans = await confirm({ message: 'Run this command now?', initialValue: false });
+        if (!isCancel(ans) && ans === true) {
+            const ok = await runCommand(audit.installCommand);
+            if (!ok)
+                throw new Error('Automatic Node/npm installation failed. Run the command above manually, then rerun npx scalemax.');
+            console.log(chalk.green('✓ Node/npm installation command completed. Re-run npx scalemax if this process does not resume automatically.'));
+            return;
+        }
+    }
+    throw new Error(`Node/npm setup is incomplete.\n${nodeUpgradeHint()}`);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "scalemax",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {
-    "scalemax": "dist/index.js"
+    "scalemax": "dist/bootstrap.cjs"
   },
   "files": [
     "dist/",