scalemax 0.1.0

package/dist/index.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { outro } from '@clack/prompts';
+import { loginCommand } from './commands/login.js';
+import { configureCommand } from './commands/configure.js';
+import { logoutCommand } from './commands/logout.js';
+import { doctorCommand } from './commands/doctor.js';
+import { modelsCommand } from './commands/models.js';
+import { updateCommand } from './commands/update.js';
+import { removeCommand } from './commands/remove.js';
+import { ensureInstallerApiKey } from './utils/installerConfig.js';
+function packageVersion() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [path.join(here, '..', 'package.json'), path.join(here, 'package.json')];
+    for (const candidate of candidates) {
+        try {
+            return JSON.parse(fs.readFileSync(candidate, 'utf8')).version || '0.0.0';
+        }
+        catch { }
+    }
+    return '0.0.0';
+}
+function welcome() {
+    console.log(chalk.cyan('╔══════════════════════════════╗'));
+    console.log(chalk.cyan('║        Welcome to ScaleMax   ║'));
+    console.log(chalk.cyan('╚══════════════════════════════╝'));
+    console.log('\nThe fastest way to connect every AI coding client.\n');
+}
+async function main() {
+    const [, , command] = process.argv;
+    try {
+        if (!command) {
+            welcome();
+            const apiKey = await ensureInstallerApiKey(process.env.HOME || process.env.USERPROFILE || process.cwd());
+            if (!apiKey)
+                return;
+            await configureCommand();
+            outro(chalk.green('ScaleMax is ready.'));
+            return;
+        }
+        switch (command) {
+            case 'login':
+                await loginCommand();
+                break;
+            case 'logout':
+                await logoutCommand();
+                break;
+            case 'doctor':
+                await doctorCommand();
+                break;
+            case 'models':
+                await modelsCommand();
+                break;
+            case 'update':
+                await updateCommand();
+                break;
+            case 'remove':
+                await removeCommand();
+                break;
+            case '--version':
+            case '-v':
+                console.log(packageVersion());
+                break;
+            case '--help':
+            case '-h':
+                console.log(`ScaleMax CLI
+
+Commands:
+  scalemax            Interactive installer
+  scalemax login      Store or replace API key
+  scalemax logout     Remove API key
+  scalemax doctor     Run diagnostics
+  scalemax models     List available models
+  scalemax update     Reconfigure detected clients
+  scalemax remove     Remove ScaleMax-generated configs
+  scalemax --version  Show installed version
+`);
+                break;
+            default: throw new Error(`Unknown command: ${command}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/types/client.d.ts

@@ -0,0 +1,32 @@
+export type ClientId = 'codex' | 'cursor' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'continue' | 'vscode' | 'windsurf';
+export interface ClientDefinition {
+    id: ClientId;
+    name: string;
+    detect: (ctx: DetectContext) => Promise<DetectionResult>;
+    configure: (ctx: ConfigureContext) => Promise<ConfigureResult>;
+    remove: (ctx: ConfigureContext) => Promise<ConfigureResult>;
+}
+export interface DetectContext {
+    home: string;
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+}
+export interface DetectionResult {
+    id: ClientId;
+    name: string;
+    installed: boolean;
+    reason?: string;
+    paths: string[];
+}
+export interface ConfigureContext extends DetectContext {
+    apiKey: string;
+    baseUrl: string;
+    dryRun?: boolean;
+}
+export interface ConfigureResult {
+    id: ClientId;
+    name: string;
+    changed: boolean;
+    path?: string;
+    message: string;
+}

package/dist/types/client.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/api.d.ts

@@ -0,0 +1,15 @@
+export interface ModelInfo {
+    id: string;
+    object?: string;
+    owned_by?: string;
+    display_name?: string;
+}
+export declare function validateApiKey(apiKey: string): Promise<{
+    ok: boolean;
+    models: ModelInfo[];
+    error?: string;
+}>;
+export declare function testStreaming(apiKey: string, model?: string): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/utils/api.js

@@ -0,0 +1,37 @@
+import { SCALEMAX_BASE_URL } from '../constants.js';
+async function request(path, apiKey, init = {}) {
+    const headers = new Headers(init.headers);
+    if (apiKey)
+        headers.set('Authorization', `Bearer ${apiKey}`);
+    if (!headers.has('Content-Type') && init.body)
+        headers.set('Content-Type', 'application/json');
+    return fetch(`${SCALEMAX_BASE_URL}${path}`, { ...init, headers });
+}
+export async function validateApiKey(apiKey) {
+    try {
+        const res = await request('/models', apiKey);
+        if (!res.ok)
+            return { ok: false, models: [], error: `HTTP ${res.status}` };
+        const data = await res.json();
+        return { ok: Array.isArray(data.data), models: data.data || [] };
+    }
+    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.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)
+            return { ok: false, error: `HTTP ${res.status}` };
+        const ct = res.headers.get('content-type') || '';
+        if (!ct.includes('text/event-stream'))
+            return { ok: false, error: `Expected event stream, got ${ct}` };
+        await res.body?.cancel().catch(() => undefined);
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/utils/exec.d.ts

@@ -0,0 +1 @@
+export declare function commandExists(command: string): Promise<boolean>;

package/dist/utils/exec.js

@@ -0,0 +1,12 @@
+import { execa } from 'execa';
+export async function commandExists(command) {
+    const checker = process.platform === 'win32' ? 'where' : 'command';
+    const args = process.platform === 'win32' ? [command] : ['-v', command];
+    try {
+        await execa(checker, args, { shell: process.platform !== 'win32' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,7 @@
+export declare function exists(p: string): Promise<boolean>;
+export declare function atomicWrite(file: string, content: string, mode?: number): Promise<void>;
+export declare function backupNameFor(file: string): string;
+export declare function backupFile(file: string, home: string): Promise<string | undefined>;
+export declare function listBackups(file: string, home: string): Promise<string[]>;
+export declare function readJson<T>(file: string, fallback: T): Promise<T>;
+export declare function writeJsonAtomic(file: string, value: unknown, mode?: number): Promise<void>;

package/dist/utils/fs.js

@@ -0,0 +1,41 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { backupDir, timestamp } from './paths.js';
+export async function exists(p) { return fs.pathExists(p); }
+export async function atomicWrite(file, content, mode = 0o600) {
+    await fs.ensureDir(path.dirname(file));
+    const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+    await fs.writeFile(tmp, content, { mode });
+    await fs.rename(tmp, file);
+    await fs.chmod(file, mode).catch(() => undefined);
+}
+export function backupNameFor(file) {
+    return file.replace(/^([A-Za-z]:)?[\/]/, '').replace(/[\/]/g, '__');
+}
+export async function backupFile(file, home) {
+    if (!(await fs.pathExists(file)))
+        return undefined;
+    const dest = path.join(backupDir(home), `${timestamp()}__${backupNameFor(file)}`);
+    await fs.ensureDir(path.dirname(dest));
+    await fs.copy(file, dest, { overwrite: false, errorOnExist: true });
+    return dest;
+}
+export async function listBackups(file, home) {
+    const dir = backupDir(home);
+    if (!(await fs.pathExists(dir)))
+        return [];
+    const suffix = `__${backupNameFor(file)}`;
+    const entries = await fs.readdir(dir);
+    return entries.filter(e => e.endsWith(suffix)).sort().reverse().map(e => path.join(dir, e));
+}
+export async function readJson(file, fallback) {
+    try {
+        return await fs.readJson(file);
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function writeJsonAtomic(file, value, mode = 0o600) {
+    await atomicWrite(file, JSON.stringify(value, null, 2) + '\n', mode);
+}

package/dist/utils/installerConfig.d.ts

@@ -0,0 +1,5 @@
+export type ExistingConfigChoice = 'keep' | 'replace' | 'remove' | 'exit';
+export declare function maskApiKey(apiKey: string): string;
+export declare function promptForValidatedKey(home: string, message?: string): Promise<string | undefined>;
+export declare function applyExistingConfigChoice(choice: ExistingConfigChoice, home: string, existing: string, getReplacement?: () => Promise<string | undefined>): Promise<string | undefined>;
+export declare function ensureInstallerApiKey(home?: string): Promise<string | undefined>;

package/dist/utils/installerConfig.js

@@ -0,0 +1,84 @@
+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 { validateApiKey } from './api.js';
+import { loadApiKey, removeApiKey, saveApiKey } from './keyStore.js';
+import { homeDir } from './paths.js';
+export function maskApiKey(apiKey) {
+    const trimmed = apiKey.trim();
+    if (trimmed.length <= 4)
+        return '••••';
+    return `${'•'.repeat(16)}${trimmed.slice(-4)}`;
+}
+export async function promptForValidatedKey(home, message = 'Enter your ScaleMax API key:') {
+    const key = await password({ message, mask: '•', validate(value) { return value.trim().length < 12 ? 'Enter a valid ScaleMax API key.' : undefined; } });
+    if (isCancel(key)) {
+        cancel('Installer cancelled.');
+        return undefined;
+    }
+    const candidate = String(key).trim();
+    const spinner = ora('Validating API key').start();
+    const result = await validateApiKey(candidate);
+    if (!result.ok) {
+        spinner.fail('Invalid API key');
+        throw new Error(result.error || 'Invalid API key');
+    }
+    await saveApiKey(candidate, SCALEMAX_BASE_URL, home);
+    spinner.succeed('API key verified and saved');
+    return candidate;
+}
+export async function applyExistingConfigChoice(choice, home, existing, getReplacement = () => promptForValidatedKey(home, 'Enter your new ScaleMax API key:')) {
+    if (choice === 'keep')
+        return existing;
+    if (choice === 'replace')
+        return getReplacement();
+    if (choice === 'remove') {
+        await removeApiKey(home);
+        return undefined;
+    }
+    return undefined;
+}
+export async function ensureInstallerApiKey(home = homeDir()) {
+    intro(chalk.cyan('ScaleMax Installer'));
+    const existing = await loadApiKey(home);
+    if (!existing) {
+        const key = await promptForValidatedKey(home, 'Enter your ScaleMax API key:');
+        if (key)
+            outro(chalk.green('ScaleMax configuration saved.'));
+        return key;
+    }
+    console.log(chalk.green('✓ Existing ScaleMax configuration detected.'));
+    console.log('\nAPI key:');
+    console.log(maskApiKey(existing));
+    const choice = await select({
+        message: 'What would you like to do?',
+        options: [
+            { value: 'keep', label: '1. Keep existing key' },
+            { value: 'replace', label: '2. Replace with a new key' },
+            { value: 'remove', label: '3. Remove configuration' },
+            { value: 'exit', label: '4. Exit' }
+        ]
+    });
+    if (isCancel(choice)) {
+        cancel('Installer cancelled.');
+        return undefined;
+    }
+    if (choice === 'remove') {
+        const ok = await confirm({ message: 'Remove stored ScaleMax configuration and API key?', initialValue: false });
+        if (isCancel(ok) || ok === false) {
+            console.log(chalk.yellow('Removal cancelled.'));
+            return existing;
+        }
+    }
+    const result = await applyExistingConfigChoice(choice, home, existing);
+    if (choice === 'keep')
+        console.log(chalk.green('✓ Keeping existing ScaleMax key.'));
+    if (choice === 'replace' && result)
+        outro(chalk.green('ScaleMax API key replaced.'));
+    if (choice === 'remove')
+        outro(chalk.green('ScaleMax configuration removed.'));
+    if (choice === 'exit')
+        console.log(chalk.yellow('Exiting without changes.'));
+    return result;
+}

package/dist/utils/keyStore.d.ts

@@ -0,0 +1,3 @@
+export declare function saveApiKey(apiKey: string, baseUrl: string, home: string): Promise<void>;
+export declare function loadApiKey(home: string): Promise<string | undefined>;
+export declare function removeApiKey(home: string): Promise<void>;

package/dist/utils/keyStore.js

@@ -0,0 +1,17 @@
+import fs from 'fs-extra';
+import { KEY_ENV } from '../constants.js';
+import { scaleMaxConfigPath, scaleMaxDir } from './paths.js';
+import { readJson, writeJsonAtomic } from './fs.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);
+}
+export async function loadApiKey(home) {
+    if (process.env[KEY_ENV])
+        return process.env[KEY_ENV];
+    const cfg = await readJson(scaleMaxConfigPath(home), {});
+    return cfg.apiKey;
+}
+export async function removeApiKey(home) {
+    await fs.remove(scaleMaxConfigPath(home));
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,7 @@
+export declare function homeDir(env?: NodeJS.ProcessEnv): string;
+export declare function configRoot(home?: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function scaleMaxDir(home?: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function scaleMaxConfigPath(home?: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function backupDir(home?: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function timestamp(): string;
+export declare function expandHome(p: string, home?: string): string;

package/dist/utils/paths.js

@@ -0,0 +1,15 @@
+import os from 'node:os';
+import path from 'node:path';
+export function homeDir(env = process.env) { return env.HOME || env.USERPROFILE || os.homedir(); }
+export function configRoot(home = homeDir(), platform = process.platform, env = process.env) {
+    if (platform === 'win32')
+        return env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    if (platform === 'darwin')
+        return path.join(home, 'Library', 'Application Support');
+    return env.XDG_CONFIG_HOME || path.join(home, '.config');
+}
+export function scaleMaxDir(home = homeDir(), platform = process.platform, env = process.env) { return path.join(configRoot(home, platform, env), 'scalemax'); }
+export function scaleMaxConfigPath(home = homeDir(), platform = process.platform, env = process.env) { return path.join(scaleMaxDir(home, platform, env), 'config.json'); }
+export function backupDir(home = homeDir(), platform = process.platform, env = process.env) { return path.join(scaleMaxDir(home, platform, env), 'backups'); }
+export function timestamp() { return new Date().toISOString().replace(/[:.]/g, '-'); }
+export function expandHome(p, home = homeDir()) { return p.startsWith('~/') ? path.join(home, p.slice(2)) : p; }

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "scalemax",
+  "version": "0.1.0",
+  "description": "Universal ScaleMax installer for AI coding clients",
+  "type": "module",
+  "bin": {
+    "scalemax": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node scripts/clean.mjs",
+    "build": "tsc -p tsconfig.json && node scripts/postbuild.mjs",
+    "test": "vitest run",
+    "lint": "node scripts/lint.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run clean && npm run typecheck && npm test && npm run lint && npm run build && npm run validate:package",
+    "validate:package": "node scripts/validate-package.mjs",
+    "pack:check": "npm run clean && npm run build && npm run validate:package && npm pack --dry-run",
+    "publish:dry-run": "npm publish --dry-run",
+    "version:patch": "npm version patch --no-git-tag-version",
+    "version:minor": "npm version minor --no-git-tag-version",
+    "version:major": "npm version major --no-git-tag-version",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "chalk": "^5.3.0",
+    "execa": "^9.5.1",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "keywords": [
+    "scalemax",
+    "ai",
+    "cli",
+    "npx",
+    "installer",
+    "codex",
+    "cursor",
+    "claude",
+    "opencode",
+    "continue",
+    "vscode",
+    "windsurf",
+    "openai-compatible"
+  ],
+  "license": "MIT",
+  "author": "ScaleMax <support@scalemax.pro>",
+  "homepage": "https://scalemax.pro",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scalemax-pro/scalemax.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://scalemax.pro",
+    "email": "support@scalemax.pro"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}