scalemax 0.1.0

package/dist/configure/codex.js

@@ -0,0 +1,210 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { execa } from 'execa';
+import { codexAuthPath, codexConfigPath } from './paths.js';
+import { atomicWrite, backupFile, listBackups } from '../utils/fs.js';
+import { GENERATED_HEADER } from '../constants.js';
+import { commandExists } from '../utils/exec.js';
+const id = 'codex';
+const name = 'Codex';
+const provider = 'scalemax';
+const model = 'gpt-5.5';
+function codexConfig(baseUrl) {
+    return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\ndisable_response_storage = true\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';
+}
+function legacyCodexConfigPath(home) {
+    return path.join(home, '.codex', 'config.json');
+}
+function parseSimpleTomlForCodex(text) {
+    const values = {};
+    let section = '';
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            continue;
+        }
+        const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*"([^"]*)"\s*$/);
+        if (match) {
+            values[section ? `${section}.${match[1]}` : match[1]] = match[2];
+            continue;
+        }
+        const boolMatch = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(true|false)\s*$/);
+        if (boolMatch)
+            values[section ? `${section}.${boolMatch[1]}` : boolMatch[1]] = boolMatch[2];
+    }
+    return values;
+}
+async function modeIsPrivate(file, platform) {
+    if (platform === 'win32')
+        return true;
+    const stat = await fs.stat(file);
+    return (stat.mode & 0o077) === 0;
+}
+async function latestRestorableBackup(file, home) {
+    for (const candidate of await listBackups(file, home)) {
+        const text = await fs.readFile(candidate, 'utf8').catch(() => '');
+        if (!text.includes(GENERATED_HEADER) && !text.includes('"scalemax.managedBy"'))
+            return candidate;
+    }
+    return undefined;
+}
+async function restoreOrRemove(file, home) {
+    const restore = await latestRestorableBackup(file, home);
+    if (restore) {
+        await fs.ensureDir(path.dirname(file));
+        await fs.copy(restore, file, { overwrite: true });
+        await fs.chmod(file, 0o600).catch(() => undefined);
+        return `restored backup ${restore}`;
+    }
+    if (await fs.pathExists(file)) {
+        await fs.remove(file);
+        return 'removed ScaleMax configuration';
+    }
+    return 'no ScaleMax configuration found';
+}
+export async function verifyCodexConfiguration(ctx) {
+    const configPath = codexConfigPath(ctx.home);
+    const authPath = codexAuthPath(ctx.home);
+    const errors = [];
+    const warnings = [];
+    if (!(await fs.pathExists(configPath)))
+        errors.push(`${configPath} does not exist`);
+    if (!(await fs.pathExists(authPath)))
+        errors.push(`${authPath} does not exist`);
+    if (errors.length)
+        return { ok: false, warnings, errors, configPath, authPath };
+    let configText = '';
+    let auth = {};
+    try {
+        configText = await fs.readFile(configPath, 'utf8');
+    }
+    catch (err) {
+        errors.push(`Cannot read ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        auth = await fs.readJson(authPath);
+    }
+    catch (err) {
+        errors.push(`${authPath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const toml = parseSimpleTomlForCodex(configText);
+    if (toml.model !== model)
+        errors.push(`Codex model mismatch: expected ${model}`);
+    if (toml.model_provider !== provider)
+        errors.push(`Codex model_provider mismatch: expected ${provider}`);
+    if (toml[`model_providers.${provider}.base_url`] !== ctx.baseUrl)
+        errors.push(`Codex base_url mismatch: expected ${ctx.baseUrl}`);
+    if (toml[`model_providers.${provider}.wire_api`] !== 'responses')
+        errors.push('Codex wire_api mismatch: expected responses');
+    if (toml[`model_providers.${provider}.requires_openai_auth`] !== 'true')
+        errors.push('Codex requires_openai_auth mismatch: expected true');
+    if (!configText.includes(`[model_providers.${provider}]`))
+        errors.push('Codex provider section is missing');
+    if (auth.auth_mode !== 'apikey')
+        errors.push('Codex auth.json missing auth_mode="apikey"');
+    if (auth.OPENAI_API_KEY !== ctx.apiKey)
+        errors.push('Codex auth.json missing the selected ScaleMax API key');
+    for (const file of [configPath, authPath]) {
+        try {
+            if (!(await modeIsPrivate(file, ctx.platform)))
+                errors.push(`${file} permissions are too broad; expected 0600-style private file`);
+        }
+        catch (err) {
+            errors.push(`Cannot stat ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (await commandExists('codex')) {
+        try {
+            const result = await execa('codex', ['doctor', '--json'], {
+                env: { ...process.env, CODEX_HOME: path.join(ctx.home, '.codex') },
+                reject: false,
+                timeout: 20000
+            });
+            const output = result.stdout || result.stderr;
+            const report = JSON.parse(output);
+            const config = report.checks?.['config.load'];
+            const authCheck = report.checks?.['auth.credentials'];
+            const reachability = report.checks?.['network.provider_reachability'];
+            if (config?.status === 'fail')
+                errors.push(`Codex rejected config.toml: ${config.summary || 'config.load failed'}`);
+            if (authCheck?.status === 'fail')
+                errors.push(`Codex rejected auth.json: ${authCheck.summary || 'auth.credentials failed'}`);
+            if (reachability?.status === 'fail')
+                warnings.push(`Codex provider reachability check failed: ${reachability.summary || 'network.provider_reachability failed'}`);
+        }
+        catch (err) {
+            warnings.push(`Could not run codex doctor for deep verification: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else {
+        warnings.push('Codex executable was not found on PATH, so launch verification was skipped.');
+    }
+    try {
+        const res = await fetch(`${ctx.baseUrl}/responses`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${ctx.apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model, input: 'Say OK', stream: false })
+        });
+        if (res.status === 404)
+            warnings.push('ScaleMax /v1/responses is not available yet. Current Codex requires the Responses API, so it may launch but cannot complete requests until the gateway supports /v1/responses.');
+        else if (res.status === 401 || res.status === 403)
+            errors.push(`ScaleMax rejected the API key on /v1/responses with HTTP ${res.status}`);
+        else if (!res.ok)
+            warnings.push(`ScaleMax /v1/responses probe returned HTTP ${res.status}`);
+    }
+    catch (err) {
+        warnings.push(`Could not probe ScaleMax /v1/responses: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { ok: errors.length === 0, warnings, errors, configPath, authPath };
+}
+export async function configure(ctx) {
+    const configPath = codexConfigPath(ctx.home);
+    const authPath = codexAuthPath(ctx.home);
+    const legacyConfig = legacyCodexConfigPath(ctx.home);
+    const backups = [];
+    await fs.ensureDir(path.dirname(configPath));
+    for (const file of [configPath, authPath, legacyConfig]) {
+        const backup = await backupFile(file, ctx.home);
+        if (backup)
+            backups.push(backup);
+    }
+    await atomicWrite(configPath, codexConfig(ctx.baseUrl), 0o600);
+    await atomicWrite(authPath, codexAuth(ctx.apiKey), 0o600);
+    if (legacyConfig.endsWith('config.json') && await fs.pathExists(legacyConfig))
+        await fs.remove(legacyConfig);
+    const verification = await verifyCodexConfiguration(ctx);
+    if (!verification.ok)
+        throw new Error(`Codex configuration verification failed:\n${verification.errors.map(e => `- ${e}`).join('\n')}`);
+    const warningText = verification.warnings.length ? ` Warnings: ${verification.warnings.join(' ')}` : '';
+    const backupText = backups.length ? ` (backups: ${backups.join(', ')})` : '';
+    return { id, name, changed: true, path: configPath, message: `configured and verified${backupText}.${warningText}` };
+}
+export async function remove(ctx) {
+    const messages = [];
+    messages.push(`config.toml: ${await restoreOrRemove(codexConfigPath(ctx.home), ctx.home)}`);
+    messages.push(`auth.json: ${await restoreOrRemove(codexAuthPath(ctx.home), ctx.home)}`);
+    const legacyConfig = legacyCodexConfigPath(ctx.home);
+    if (legacyConfig.endsWith('config.json'))
+        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 launchCodex() {
+    if (!(await commandExists('codex')))
+        return { ok: false, message: 'Codex executable was not found on PATH.' };
+    try {
+        const result = await execa('codex', [], { stdio: 'inherit', reject: false });
+        if (result.exitCode === 0)
+            return { ok: true, message: 'Codex launched successfully.' };
+        return { ok: false, message: `Codex exited with code ${result.exitCode}.`, output: result.stderr || result.stdout };
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to launch Codex: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}

package/dist/configure/common.d.ts

@@ -0,0 +1,4 @@
+import { ConfigureContext, ConfigureResult, ClientId } from '../types/client.js';
+export declare function writeManagedConfig(ctx: ConfigureContext, id: ClientId, name: string, file: string, content: string): Promise<ConfigureResult>;
+export declare function writeMergedJsonConfig(ctx: ConfigureContext, id: ClientId, name: string, file: string, build: (existing: Record<string, unknown>) => string): Promise<ConfigureResult>;
+export declare function removeManagedConfig(ctx: ConfigureContext, id: ClientId, name: string, file: string): Promise<ConfigureResult>;

package/dist/configure/common.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { atomicWrite, backupFile, listBackups, readJson } from '../utils/fs.js';
+import { GENERATED_HEADER } from '../constants.js';
+export async function writeManagedConfig(ctx, id, name, file, content) {
+    await fs.ensureDir(path.dirname(file));
+    const backup = await backupFile(file, ctx.home);
+    await atomicWrite(file, content, 0o600);
+    return { id, name, changed: true, path: file, message: backup ? `configured (backup: ${backup})` : 'configured' };
+}
+export async function writeMergedJsonConfig(ctx, id, name, file, build) {
+    await fs.ensureDir(path.dirname(file));
+    const existing = await readJson(file, {});
+    const backup = await backupFile(file, ctx.home);
+    await atomicWrite(file, build(existing), 0o600);
+    return { id, name, changed: true, path: file, message: backup ? `configured (backup: ${backup})` : 'configured' };
+}
+async function latestRestorableBackup(file, home) {
+    for (const candidate of await listBackups(file, home)) {
+        const text = await fs.readFile(candidate, 'utf8').catch(() => '');
+        if (!text.includes(GENERATED_HEADER) && !text.includes('"scalemax.managedBy"'))
+            return candidate;
+    }
+    return undefined;
+}
+export async function removeManagedConfig(ctx, id, name, file) {
+    const restore = await latestRestorableBackup(file, ctx.home);
+    if (restore) {
+        await fs.ensureDir(path.dirname(file));
+        await fs.copy(restore, file, { overwrite: true });
+        await fs.chmod(file, 0o600).catch(() => undefined);
+        return { id, name, changed: true, path: file, message: `restored backup ${restore}` };
+    }
+    if (await fs.pathExists(file)) {
+        await fs.remove(file);
+        return { id, name, changed: true, path: file, message: 'removed ScaleMax configuration' };
+    }
+    return { id, name, changed: false, path: file, message: 'no ScaleMax configuration found' };
+}

package/dist/configure/continue.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/continue.js

@@ -0,0 +1,12 @@
+import { clientConfigPath } from './paths.js';
+import { writeManagedConfig, removeManagedConfig } from './common.js';
+import { continueConfig } from './templates.js';
+const id = 'continue';
+const name = 'Continue';
+export async function configure(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return writeManagedConfig(ctx, id, name, file, continueConfig(ctx.apiKey, ctx.baseUrl));
+}
+export async function remove(ctx) {
+    return removeManagedConfig(ctx, id, name, clientConfigPath(id, ctx.home, ctx.platform));
+}

package/dist/configure/cursor.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/cursor.js

@@ -0,0 +1,13 @@
+import { clientConfigPath } from './paths.js';
+import { removeManagedConfig, writeMergedJsonConfig } from './common.js';
+import { editorSettings } from './templates.js';
+const id = 'cursor';
+const name = 'Cursor';
+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));
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/configure/hermes.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/hermes.js

@@ -0,0 +1,14 @@
+import { clientConfigPath } from './paths.js';
+import { writeManagedConfig, removeManagedConfig } from './common.js';
+import { jsonConfig } from './templates.js';
+const id = 'hermes';
+const name = 'Hermes';
+export async function configure(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl);
+    return writeManagedConfig(ctx, id, name, file, content);
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/configure/openclaw.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/openclaw.js

@@ -0,0 +1,14 @@
+import { clientConfigPath } from './paths.js';
+import { writeManagedConfig, removeManagedConfig } from './common.js';
+import { jsonConfig } from './templates.js';
+const id = 'openclaw';
+const name = 'OpenClaw';
+export async function configure(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl);
+    return writeManagedConfig(ctx, id, name, file, content);
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/configure/opencode.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/opencode.js

@@ -0,0 +1,14 @@
+import { clientConfigPath } from './paths.js';
+import { writeManagedConfig, removeManagedConfig } from './common.js';
+import { jsonConfig } from './templates.js';
+const id = 'opencode';
+const name = 'OpenCode';
+export async function configure(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl);
+    return writeManagedConfig(ctx, id, name, file, content);
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/configure/paths.d.ts

@@ -0,0 +1,6 @@
+import { ClientId } from '../types/client.js';
+export declare function codexDir(home: string): string;
+export declare function codexConfigPath(home: string): string;
+export declare function codexAuthPath(home: string): string;
+export declare function clientConfigPath(id: ClientId, home: string, platform: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function installHints(id: ClientId, home: string, platform: NodeJS.Platform, env?: NodeJS.ProcessEnv): string[];

package/dist/configure/paths.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { configRoot } from '../utils/paths.js';
+export function codexDir(home) { return path.join(home, '.codex'); }
+export function codexConfigPath(home) { return path.join(codexDir(home), 'config.toml'); }
+export function codexAuthPath(home) { return path.join(codexDir(home), 'auth.json'); }
+export function clientConfigPath(id, home, platform, env = process.env) {
+    const app = configRoot(home, platform, env);
+    const linux = env.XDG_CONFIG_HOME || path.join(home, '.config');
+    switch (id) {
+        case 'codex': return codexConfigPath(home);
+        case 'cursor': return platform === 'win32' ? path.join(app, 'Cursor', 'User', 'settings.json') : platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json') : path.join(linux, 'Cursor', 'User', 'settings.json');
+        case 'claude': return path.join(home, '.claude', 'settings.json');
+        case 'opencode': return path.join(linux, 'opencode', 'config.json');
+        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 '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');
+    }
+}
+export function installHints(id, home, platform, env = process.env) {
+    const app = configRoot(home, platform, env);
+    const linux = env.XDG_CONFIG_HOME || path.join(home, '.config');
+    switch (id) {
+        case 'codex': return [codexDir(home), path.join(linux, 'codex')];
+        case 'cursor': return [platform === 'darwin' ? '/Applications/Cursor.app' : path.join(app, 'Cursor'), path.join(linux, 'Cursor')];
+        case 'claude': return [path.join(home, '.claude')];
+        case 'opencode': return [path.join(linux, 'opencode')];
+        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 '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/templates.d.ts

@@ -0,0 +1,3 @@
+export declare function jsonConfig(client: string, apiKey: string, baseUrl: string, extra?: Record<string, unknown>): string;
+export declare function continueConfig(apiKey: string, baseUrl: string): string;
+export declare function editorSettings(client: string, apiKey: string, baseUrl: string, existing?: Record<string, unknown>): string;

package/dist/configure/templates.js

@@ -0,0 +1,31 @@
+import { GENERATED_HEADER } from '../constants.js';
+export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
+    return JSON.stringify({
+        $schema: 'https://scalemax.pro/schemas/client-config.json',
+        managedBy: GENERATED_HEADER,
+        client,
+        provider: 'openai-compatible',
+        baseURL: baseUrl,
+        apiKey,
+        ...extra
+    }, null, 2) + '\n';
+}
+export function continueConfig(apiKey, baseUrl) {
+    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 },
+        contextProviders: [{ name: 'code' }, { name: 'docs' }, { name: 'diff' }, { name: 'terminal' }]
+    }, null, 2) + '\n';
+}
+export function editorSettings(client, apiKey, baseUrl, existing = {}) {
+    return JSON.stringify({
+        ...existing,
+        'scalemax.managedBy': GENERATED_HEADER,
+        'scalemax.baseURL': baseUrl,
+        'scalemax.apiKey': apiKey,
+        'scalemax.provider': 'openai-compatible',
+        'scalemax.client': client,
+        'openai.baseURL': baseUrl,
+        'openai.apiKey': apiKey
+    }, null, 2) + '\n';
+}

package/dist/configure/vscode.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/vscode.js

@@ -0,0 +1,13 @@
+import { clientConfigPath } from './paths.js';
+import { removeManagedConfig, writeMergedJsonConfig } from './common.js';
+import { editorSettings } from './templates.js';
+const id = 'vscode';
+const name = '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));
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/configure/windsurf.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/windsurf.js

@@ -0,0 +1,13 @@
+import { clientConfigPath } from './paths.js';
+import { removeManagedConfig, writeMergedJsonConfig } from './common.js';
+import { editorSettings } from './templates.js';
+const id = 'windsurf';
+const name = 'Windsurf';
+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));
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    return removeManagedConfig(ctx, id, name, file);
+}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SCALEMAX_BASE_URL = "https://api.scalemax.pro/v1";
+export declare const APP_NAME = "ScaleMax";
+export declare const GENERATED_HEADER = "ScaleMax managed configuration";
+export declare const KEY_ENV = "SCALEMAX_API_KEY";

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const SCALEMAX_BASE_URL = 'https://api.scalemax.pro/v1';
+export const APP_NAME = 'ScaleMax';
+export const GENERATED_HEADER = 'ScaleMax managed configuration';
+export const KEY_ENV = 'SCALEMAX_API_KEY';

package/dist/detect/claude.d.ts

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

package/dist/detect/claude.js

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

package/dist/detect/codex.d.ts

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

package/dist/detect/codex.js

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

package/dist/detect/common.d.ts

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

package/dist/detect/common.js

@@ -0,0 +1,19 @@
+import fs from 'fs-extra';
+import { commandExists } from '../utils/exec.js';
+import { clientConfigPath, installHints } from '../configure/paths.js';
+const commands = {
+    codex: ['codex'], cursor: ['cursor'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], continue: ['continue'], vscode: ['code'], 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)];
+    const pathHits = [];
+    for (const p of paths)
+        if (await fs.pathExists(p))
+            pathHits.push(p);
+    const cmdHits = [];
+    for (const cmd of commands[id])
+        if (await commandExists(cmd))
+            cmdHits.push(`command:${cmd}`);
+    const hits = [...cmdHits, ...pathHits];
+    return { id, name, installed: hits.length > 0, reason: hits.length ? undefined : 'not detected', paths: hits };
+}

package/dist/detect/continue.d.ts

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

package/dist/detect/continue.js

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

package/dist/detect/cursor.d.ts

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

package/dist/detect/cursor.js

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

package/dist/detect/hermes.d.ts

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

package/dist/detect/hermes.js

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

package/dist/detect/openclaw.d.ts

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

package/dist/detect/openclaw.js

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

package/dist/detect/opencode.d.ts

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

package/dist/detect/opencode.js

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

package/dist/detect/vscode.d.ts

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

package/dist/detect/vscode.js

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

package/dist/detect/windsurf.d.ts

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

package/dist/detect/windsurf.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};