scalemax 0.1.3 → 0.1.5

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

@@ -2,8 +2,6 @@ import * as codexDetect from './detect/codex.js';
 import * as codexConfig from './configure/codex.js';
 import * as cursorDetect from './detect/cursor.js';
 import * as cursorConfig from './configure/cursor.js';
-import * as claudeDetect from './detect/claude.js';
-import * as claudeConfig from './configure/claude.js';
 import * as opencodeDetect from './detect/opencode.js';
 import * as opencodeConfig from './configure/opencode.js';
 import * as openclawDetect from './detect/openclaw.js';
@@ -14,16 +12,21 @@ import * as continueDetect from './detect/continue.js';
 import * as continueConfig from './configure/continue.js';
 import * as vscodeDetect from './detect/vscode.js';
 import * as vscodeConfig from './configure/vscode.js';
+import * as rooDetect from './detect/roo.js';
+import * as rooConfig from './configure/roo.js';
+import * as clineDetect from './detect/cline.js';
+import * as clineConfig from './configure/cline.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 },
     { id: 'openclaw', name: 'OpenClaw', detect: openclawDetect.detect, configure: openclawConfig.configure, remove: openclawConfig.remove },
     { id: 'hermes', name: 'Hermes', detect: hermesDetect.detect, configure: hermesConfig.configure, remove: hermesConfig.remove },
-    { id: 'vscode', name: 'VS Code', detect: vscodeDetect.detect, configure: vscodeConfig.configure, remove: vscodeConfig.remove },
+    { id: 'vscode', name: 'Continue Extension (VS Code)', detect: vscodeDetect.detect, configure: vscodeConfig.configure, remove: vscodeConfig.remove },
+    { id: 'roo', name: 'Roo Code (VS Code)', detect: rooDetect.detect, configure: rooConfig.configure, remove: rooConfig.remove },
+    { id: 'cline', name: 'Cline (VS Code)', detect: clineDetect.detect, configure: clineConfig.configure, remove: clineConfig.remove },
     { id: 'continue', name: 'Continue', detect: continueDetect.detect, configure: continueConfig.configure, remove: continueConfig.remove },
     { id: 'windsurf', name: 'Windsurf', detect: windsurfDetect.detect, configure: windsurfConfig.configure, remove: windsurfConfig.remove }
 ];

package/dist/commands/configure.js

@@ -5,8 +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';
-import { ensureCodexInstalled } from '../install/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)));
@@ -27,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');
 }
@@ -62,20 +63,31 @@ export async function configureCommand(opts = {}) {
         console.log(chalk.yellow('No detected clients to configure.'));
         return;
     }
-    if (chosen.includes('codex')) {
-        const install = await ensureCodexInstalled(process.stdin.isTTY);
-        if (!install.ok)
-            console.log(chalk.yellow(install.message));
-        else
-            console.log(chalk.green(`✓ ${install.message}`));
-    }
     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/cline.d.ts

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

package/dist/configure/cline.js

@@ -0,0 +1,13 @@
+const id = 'cline';
+const name = 'Cline (VS Code)';
+export async function configure(ctx) {
+    return {
+        id,
+        name,
+        changed: false,
+        message: `detected. Open the extension settings and select API Provider: OpenAI Compatible; Base URL: ${ctx.baseUrl}; API Key: your ScaleMax key; Model ID: gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, or codex-auto-review. Official docs: https://docs.cline.bot/provider-config/openai-compatible`,
+    };
+}
+export async function remove(_ctx) {
+    return { id, name, changed: false, message: 'Roo/Cline settings are stored inside VS Code extension state. Remove or edit them from the extension settings UI.' };
+}

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/configure/paths.js

@@ -14,6 +14,8 @@ export function clientConfigPath(id, home, platform, env = process.env) {
         case 'openclaw': return path.join(home, '.openclaw', 'config.json');
         case 'hermes': return path.join(home, '.hermes', 'config', 'scalemax.json');
         case 'continue': return path.join(home, '.continue', 'config.json');
+        case 'roo': return path.join(home, '.scalemax', 'roo-code-vscode.manual.json');
+        case 'cline': return path.join(home, '.scalemax', 'cline-vscode.manual.json');
         case 'vscode': return platform === 'win32' ? path.join(app, 'Code', 'User', 'settings.json') : platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json') : path.join(linux, 'Code', 'User', 'settings.json');
         case 'windsurf': return platform === 'win32' ? path.join(app, 'Windsurf', 'User', 'settings.json') : platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'Windsurf', 'User', 'settings.json') : path.join(linux, 'Windsurf', 'User', 'settings.json');
     }
@@ -29,6 +31,8 @@ export function installHints(id, home, platform, env = process.env) {
         case 'openclaw': return [path.join(home, '.openclaw'), path.join(linux, 'openclaw')];
         case 'hermes': return [path.join(home, '.hermes')];
         case 'continue': return [path.join(home, '.continue')];
+        case 'roo': return [];
+        case 'cline': return [];
         case 'vscode': return [platform === 'darwin' ? '/Applications/Visual Studio Code.app' : path.join(app, 'Code'), path.join(linux, 'Code')];
         case 'windsurf': return [platform === 'darwin' ? '/Applications/Windsurf.app' : path.join(app, 'Windsurf'), path.join(linux, 'Windsurf')];
     }

package/dist/configure/roo.d.ts

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

package/dist/configure/roo.js

@@ -0,0 +1,13 @@
+const id = 'roo';
+const name = 'Roo Code (VS Code)';
+export async function configure(ctx) {
+    return {
+        id,
+        name,
+        changed: false,
+        message: `detected. Open the extension settings and select API Provider: OpenAI Compatible; Base URL: ${ctx.baseUrl}; API Key: your ScaleMax key; Model ID: gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, or codex-auto-review. Official docs: https://docs.roocode.com/providers/openai-compatible`,
+    };
+}
+export async function remove(_ctx) {
+    return { id, name, changed: false, message: 'Roo/Cline settings are stored inside VS Code extension state. Remove or edit them from the extension settings UI.' };
+}

package/dist/configure/templates.js

@@ -11,9 +11,16 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
+    const models = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review'];
     return JSON.stringify({
-        models: [{ title: 'ScaleMax', provider: 'openai', model: 'gpt-5.5', apiBase: baseUrl, apiKey }],
-        tabAutocompleteModel: { title: 'ScaleMax', provider: 'openai', model: 'gpt-5.5', apiBase: baseUrl, apiKey },
+        models: models.map(model => ({
+            title: `ScaleMax ${model}`,
+            provider: 'openai',
+            model,
+            apiBase: baseUrl,
+            apiKey
+        })),
+        tabAutocompleteModel: { title: 'ScaleMax gpt-5.4-mini', provider: 'openai', model: 'gpt-5.4-mini', apiBase: baseUrl, apiKey },
         contextProviders: [{ name: 'code' }, { name: 'docs' }, { name: 'diff' }, { name: 'terminal' }]
     }, null, 2) + '\n';
 }

package/dist/configure/vscode.js

@@ -1,13 +1,13 @@
 import { clientConfigPath } from './paths.js';
-import { removeManagedConfig, writeMergedJsonConfig } from './common.js';
-import { editorSettings } from './templates.js';
+import { removeManagedConfig, writeManagedConfig } from './common.js';
+import { continueConfig } from './templates.js';
 const id = 'vscode';
-const name = 'VS Code';
+const name = 'Continue Extension (VS Code)';
 export async function configure(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return writeMergedJsonConfig(ctx, id, name, file, existing => editorSettings(name, ctx.apiKey, ctx.baseUrl, existing));
+    const file = clientConfigPath('continue', ctx.home, ctx.platform);
+    return writeManagedConfig(ctx, id, name, file, continueConfig(ctx.apiKey, ctx.baseUrl));
 }
 export async function remove(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const file = clientConfigPath('continue', ctx.home, ctx.platform);
     return removeManagedConfig(ctx, id, name, file);
 }

package/dist/detect/cline.d.ts

@@ -0,0 +1,2 @@
+import { DetectContext, DetectionResult } from '../types/client.js';
+export declare function detect(ctx: DetectContext): Promise<DetectionResult>;

package/dist/detect/cline.js

@@ -0,0 +1,2 @@
+import { detectClient } from './common.js';
+export function detect(ctx) { return detectClient(ctx, 'cline', 'Cline (VS Code)'); }

package/dist/detect/common.js

@@ -1,8 +1,30 @@
 import fs from 'fs-extra';
 import { commandExists } from '../utils/exec.js';
 import { clientConfigPath, installHints } from '../configure/paths.js';
+function vscodeExtensionRoots(ctx) {
+    const app = ctx.env.APPDATA || '';
+    const xdg = ctx.env.XDG_DATA_HOME || pathJoin(ctx.home, '.local', 'share');
+    if (ctx.platform === 'win32')
+        return [pathJoin(ctx.home, '.vscode', 'extensions'), pathJoin(app, 'Code', 'User', 'globalStorage')];
+    if (ctx.platform === 'darwin')
+        return [pathJoin(ctx.home, '.vscode', 'extensions'), pathJoin(ctx.home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage')];
+    return [pathJoin(ctx.home, '.vscode', 'extensions'), pathJoin(xdg, 'Code', 'User', 'globalStorage')];
+}
+function pathJoin(...parts) { return parts.filter(Boolean).join('/'); }
+async function detectVsCodeExtension(ctx, patterns) {
+    const hits = [];
+    for (const root of vscodeExtensionRoots(ctx)) {
+        const entries = await fs.readdir(root).catch(() => []);
+        for (const entry of entries) {
+            const lower = entry.toLowerCase();
+            if (patterns.some(pattern => lower.includes(pattern)))
+                hits.push(`${root}/${entry}`);
+        }
+    }
+    return hits;
+}
 const commands = {
-    codex: ['codex'], cursor: ['cursor'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], continue: ['continue'], vscode: ['code'], windsurf: ['windsurf']
+    codex: ['codex'], cursor: ['cursor'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], continue: ['continue'], vscode: ['code'], roo: [], cline: [], windsurf: ['windsurf']
 };
 export async function detectClient(ctx, id, name) {
     const paths = [clientConfigPath(id, ctx.home, ctx.platform, ctx.env), ...installHints(id, ctx.home, ctx.platform, ctx.env)];
@@ -14,6 +36,11 @@ export async function detectClient(ctx, id, name) {
     for (const cmd of commands[id])
         if (await commandExists(cmd))
             cmdHits.push(`command:${cmd}`);
-    const hits = [...cmdHits, ...pathHits];
+    const extensionHits = id === 'roo'
+        ? await detectVsCodeExtension(ctx, ['rooveterinaryinc.roo-cline', 'roo-cline', 'roo-code'])
+        : id === 'cline'
+            ? await detectVsCodeExtension(ctx, ['saoudrizwan.claude-dev', 'cline.cline'])
+            : [];
+    const hits = [...cmdHits, ...pathHits, ...extensionHits];
     return { id, name, installed: hits.length > 0, reason: hits.length ? undefined : 'not detected', paths: hits };
 }

package/dist/detect/roo.d.ts

@@ -0,0 +1,2 @@
+import { DetectContext, DetectionResult } from '../types/client.js';
+export declare function detect(ctx: DetectContext): Promise<DetectionResult>;

package/dist/detect/roo.js

@@ -0,0 +1,2 @@
+import { detectClient } from './common.js';
+export function detect(ctx) { return detectClient(ctx, 'roo', 'Roo Code (VS Code)'); }

package/dist/index.js

@@ -12,7 +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, runtimeReport } from './utils/runtime.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')];
@@ -41,11 +42,11 @@ async function main() {
     try {
         if (!command) {
             welcome();
-            console.log(await runtimeReport());
+            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/types/client.d.ts

@@ -1,9 +1,12 @@
-export type ClientId = 'codex' | 'cursor' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'continue' | 'vscode' | 'windsurf';
+export type ClientId = 'codex' | 'cursor' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'continue' | 'vscode' | 'roo' | 'cline' | 'windsurf';
 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 {
@@ -21,6 +24,9 @@ export interface DetectionResult {
     configured?: boolean;
     installable?: boolean;
 }
+export interface InstallContext extends DetectContext {
+    interactive?: boolean;
+}
 export interface ConfigureContext extends DetectContext {
     apiKey: string;
     baseUrl: string;

package/dist/utils/runtime.d.ts

@@ -1,6 +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 runtimeReport(): Promise<string>;
+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

@@ -1,5 +1,8 @@
+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)
@@ -12,5 +15,58 @@ export async function npmVersion() { try {
 catch {
     return undefined;
 } }
-export async function runtimeReport() { return `Node ${process.versions.node} ${isNodeSupported() ? '✓' : '✗'} (required >=${MIN_NODE}) · npm ${await npmVersion() || 'not found'}`; }
-export function nodeUpgradeHint() { return ['Install Node.js LTS, then rerun: npx scalemax@latest', 'macOS Homebrew: brew install node', 'nvm: nvm install --lts && nvm use --lts', 'fnm: fnm install --lts && fnm use --lts', 'volta: volta install node@lts npm'].join('\\n'); }
+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.3",
+  "version": "0.1.5",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {
-    "scalemax": "dist/index.js"
+    "scalemax": "dist/bootstrap.cjs"
   },
   "files": [
     "dist/",
@@ -51,10 +51,11 @@
     "installer",
     "codex",
     "cursor",
-    "claude",
     "opencode",
     "continue",
     "vscode",
+    "roo-code",
+    "cline",
     "windsurf",
     "openai-compatible"
   ],