scalemax 0.1.32 → 0.1.33

package/README.md

@@ -136,6 +136,7 @@ The helper refuses unrelated requests and redacts ScaleMax-style secrets from pr
 - Codex
 - Cursor
 - Roo Code (VS Code)
+- Cline (CLI and VS Code)
 - Continue (VS Code)
 - TRAE SOLO
 - Claude Code
@@ -171,6 +172,10 @@ ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and
 
 Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex, Claude, and tool-capable DeepSeek profiles remain separate. DeepSeek is offered only when authenticated discovery reports `capabilities.tools=true`; otherwise Roo fails closed and points the user to Continue Chat/Edit. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
 
+### Cline (CLI and VS Code)
+
+ScaleMax supports the verified Cline CLI `3.0.47` and VS Code extension `4.0.12` formats. The CLI surface uses Cline's built-in `openai-native` provider and Responses protocol. The extension uses its built-in OpenAI-compatible provider. Both receive the raw ScaleMax key and the matching credit or token base URL; ScaleMax never writes a custom `Authorization` or `x-api-key` header because Cline generates `Authorization: Bearer …` itself. Configuration is attempted only while Cline and VS Code are stopped, preserves unrelated state, uses private atomic files with backups and rollback, and fails closed on unknown versions or malformed/symlinked state.
+
 ### Continue (VS Code)
 
 Continue is the universal VS Code Chat/Edit route for `deepseek-v4-flash`. The CLI installs the official `Continue.continue` extension when VS Code is available, merges an OpenAI-compatible model into `~/.continue/config.yaml`, sets `useResponsesApi: false`, and keeps the authenticated ScaleMax key in private `~/.continue/.env` rather than the YAML. Existing Continue models and environment entries are preserved. Reload VS Code and select **ScaleMax DeepSeek V4 Flash**. For agent workflows, prefer Roo/OpenClaw/Hermes when the authenticated catalog reports `capabilities.tools=true`.

package/dist/clients.js

@@ -4,6 +4,8 @@ import * as cursorDetect from './detect/cursor.js';
 import * as cursorConfig from './configure/cursor.js';
 import * as rooCodeDetect from './detect/roo-code.js';
 import * as rooCodeConfig from './configure/roo-code.js';
+import * as clineDetect from './detect/cline.js';
+import * as clineConfig from './configure/cline.js';
 import * as continueDetect from './detect/continue.js';
 import * as continueConfig from './configure/continue.js';
 import * as traeSoloDetect from './detect/trae-solo.js';
@@ -24,6 +26,7 @@ export const clients = [
     { 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, verify: cursorConfig.verify, remove: cursorConfig.remove },
     { id: 'roo-code', name: 'Roo Code (VS Code)', detect: rooCodeDetect.detect, configure: rooCodeConfig.configure, verify: rooCodeConfig.verify, remove: rooCodeConfig.remove },
+    { id: 'cline', name: 'Cline', detect: clineDetect.detect, install: clineConfig.install, configure: clineConfig.configure, verify: clineConfig.verify, remove: clineConfig.remove },
     { id: 'continue', name: 'Continue (VS Code)', detect: continueDetect.detect, install: continueConfig.install, configure: continueConfig.configure, verify: continueConfig.verify, remove: continueConfig.remove },
     { id: 'trae-solo', name: 'TRAE SOLO', detect: traeSoloDetect.detect, configure: traeSoloConfig.configure, remove: traeSoloConfig.remove },
     { id: 'claude', name: 'Claude Code', detect: claudeDetect.detect, configure: claudeConfig.configure, verify: claudeConfig.verify, remove: claudeConfig.remove },

package/dist/commands/configure.js

@@ -48,7 +48,7 @@ export function clientAllowedForModels(clientId, models) {
     // normalized OpenAI-compatible Chat Completions route, which supports both
     // authenticated model families. Codex remains Responses-only; TRAE uses
     // OpenAI-compatible Chat Completions.
-    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'cline', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
     if (clientId === 'continue')
         return models.some(model => isExactChatCompletionsModelId(model.id));
     if (clientId === 'claude')
@@ -60,7 +60,7 @@ export function clientAllowedForModels(clientId, models) {
     // Roo is an agent, not a text-only chat surface. Its task loop depends on
     // native function calls for every model family, so offer it only when the
     // authenticated catalog confirms at least one viable route.
-    if (clientId === 'roo-code')
+    if (clientId === 'roo-code' || clientId === 'cline')
         return models.some(model => model.capabilities?.tools === true);
     if (crossProtocolClients.has(clientId))
         return true;

package/dist/commands/helper-bot.js

@@ -763,6 +763,7 @@ For automatic configuration, exit with \`/quit\`, run \`scalemax update\`, then
 const HELPER_CLIENT_PATTERNS = [
     { id: 'continue', pattern: /\b(?:continue(?:\.dev)?|vscode\s+continue|vs\s+code\s+continue)\b/i },
     { id: 'roo-code', pattern: /\b(?:roo(?:\s+code)?|roo\s+(?:extension|plugin)|vscode\s+roo|vs\s+code\s+roo)\b/i },
+    { id: 'cline', pattern: /\bcline(?:\s+(?:extension|plugin|cli))?\b/i },
     { id: 'openclaw', pattern: /\bopen\s*claw\b/i },
     { id: 'opencode', pattern: /\bopen\s*code\b/i },
     { id: 'cherry-studio', pattern: /\bcherry\s*studio\b/i },
@@ -841,7 +842,7 @@ function actionModels(connection, requestedScope) {
 function helperClientAllowedForModels(clientId, models) {
     if (!models.length)
         return false;
-    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'cline', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
     const onlyExactChat = models.every(model => isExactChatCompletionsModelId(model.id));
     if (clientId === 'continue')
         return onlyExactChat;
@@ -851,7 +852,7 @@ function helperClientAllowedForModels(clientId, models) {
         return false;
     if (clientId === 'hermes' && onlyExactChat)
         return models.some(model => model.capabilities?.tools === true);
-    if (clientId === 'roo-code')
+    if (clientId === 'roo-code' || clientId === 'cline')
         return models.some(model => model.capabilities?.tools === true);
     if (crossProtocolClients.has(clientId))
         return true;
@@ -1014,7 +1015,9 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
     }
     const activation = client.id === 'roo-code'
         ? ' Reload VS Code once so Roo Code imports the verified ScaleMax profile.'
-        : client.id === 'continue' ? ' Reload VS Code once so Continue loads the verified ScaleMax profile.' : '';
+        : client.id === 'cline'
+            ? ' Restart Cline; reload VS Code too when using the extension.'
+            : client.id === 'continue' ? ' Reload VS Code once so Continue loads the verified ScaleMax profile.' : '';
     return `✅ Successfully completed: ${client.name} is configured and locally verified.${activation}`;
 }
 /** Execute only narrowly allowlisted ScaleMax client actions; never model-generated shell commands. */

package/dist/configure/cline.d.ts

@@ -0,0 +1,29 @@
+import { ConfigureContext, ConfigureResult, DetectContext, InstallContext } from '../types/client.js';
+export interface ClineExtensionSurface {
+    path: string;
+    version?: string;
+    supported: boolean;
+}
+export interface ClineSurfaces {
+    cliInstalled: boolean;
+    cliVersion?: string;
+    cliSupported: boolean;
+    extensions: ClineExtensionSurface[];
+    extensionInstalled: boolean;
+    extensionSupported: boolean;
+}
+export declare function clineExtensionStatePaths(ctx: Pick<DetectContext, 'home' | 'env'>): {
+    globalStateFile: string;
+    secretsFile: string;
+};
+export declare function inspectClineSurfaces(ctx: DetectContext): Promise<ClineSurfaces>;
+export declare function clineProcessConflicts(output: string, platform: NodeJS.Platform): {
+    cli: boolean;
+    extension: boolean;
+};
+export declare function install(ctx: InstallContext): Promise<ConfigureResult>;
+export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function isManagedCliStore(value: unknown): boolean;
+export declare function isManagedExtensionState(globalState: unknown, secrets: unknown): boolean;
+export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/cline.js

@@ -0,0 +1,581 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { commandExists } from '../utils/exec.js';
+import { atomicWrite, backupFile } from '../utils/fs.js';
+import { clientConfigPath, installHints } from './paths.js';
+import { modelSupportsTools, openAiResponsesModelIds, preferredChatCompletionsModel, preferredOpenAiResponsesModel, } from './models.js';
+const id = 'cline';
+const name = 'Cline';
+const cliVersion = '3.0.47';
+const extensionVersion = '4.0.12';
+const extensionId = 'saoudrizwan.claude-dev';
+const cliProviderId = 'openai-native';
+const legacyProviderId = 'scalemax';
+const scaleMaxBaseUrl = /^https:\/\/api\.scalemax\.pro\/(?:token\/)?v1\/?$/i;
+function clineDataDir(ctx) {
+    return ctx.env.CLINE_DATA_DIR?.trim()
+        || path.join(ctx.env.CLINE_DIR?.trim() || path.join(ctx.home, '.cline'), 'data');
+}
+export function clineExtensionStatePaths(ctx) {
+    const data = clineDataDir(ctx);
+    return {
+        globalStateFile: path.join(data, 'globalState.json'),
+        secretsFile: path.join(data, 'secrets.json'),
+    };
+}
+function legacyModelsPath(ctx) {
+    return path.join(path.dirname(clientConfigPath(id, ctx.home, ctx.platform, ctx.env)), 'models.json');
+}
+function asObject(value, file) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Refusing to overwrite invalid Cline configuration at ${file}: root value must be an object.`);
+    }
+    return value;
+}
+async function regularFileExists(file) {
+    const stat = await fs.lstat(file).catch(() => undefined);
+    if (!stat)
+        return false;
+    if (stat.isSymbolicLink())
+        throw new Error(`Refusing to read or overwrite symlinked Cline configuration: ${file}`);
+    if (!stat.isFile())
+        throw new Error(`Refusing to overwrite non-file Cline configuration path: ${file}`);
+    return true;
+}
+async function readObject(file) {
+    if (!(await regularFileExists(file)))
+        return {};
+    try {
+        return asObject(JSON.parse(await fs.readFile(file, 'utf8')), file);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('Refusing to overwrite'))
+            throw error;
+        throw new Error(`Refusing to overwrite invalid Cline configuration at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function readProviderStore(file) {
+    if (!(await regularFileExists(file)))
+        return { version: 1, providers: {} };
+    const value = await readObject(file);
+    if (value.version !== 1 || !value.providers || typeof value.providers !== 'object' || Array.isArray(value.providers)) {
+        throw new Error(`Refusing to overwrite unsupported Cline CLI provider configuration at ${file}.`);
+    }
+    return value;
+}
+async function readLegacyModelStore(file) {
+    if (!(await regularFileExists(file)))
+        return undefined;
+    const value = await readObject(file);
+    if (value.version !== 1 || !value.providers || typeof value.providers !== 'object' || Array.isArray(value.providers)) {
+        throw new Error(`Refusing to overwrite unsupported Cline CLI model configuration at ${file}.`);
+    }
+    return value;
+}
+function parseVersion(output) {
+    return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
+}
+async function cliInstalledVersion(env) {
+    if (!(await commandExists('cline', env)))
+        return { installed: false };
+    const result = await execa('cline', ['--version'], {
+        env,
+        reject: false,
+        timeout: 5_000,
+        all: true,
+    });
+    return {
+        installed: true,
+        version: parseVersion(result.all || result.stdout || ''),
+    };
+}
+async function extensionSurfaces(ctx) {
+    const hits = [];
+    const roots = installHints(id, ctx.home, ctx.platform, ctx.env)
+        .filter(candidate => path.basename(candidate).toLowerCase() === 'extensions');
+    for (const root of roots) {
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !/^saoudrizwan\.claude-dev-/i.test(entry.name))
+                continue;
+            const extensionPath = path.join(root, entry.name);
+            const manifest = await fs.readJson(path.join(extensionPath, 'package.json')).catch(() => undefined);
+            const version = typeof manifest?.version === 'string' ? manifest.version : undefined;
+            const identityMatches = String(manifest?.publisher || '').toLowerCase() === 'saoudrizwan'
+                && String(manifest?.name || '').toLowerCase() === 'claude-dev';
+            hits.push({
+                path: extensionPath,
+                version,
+                supported: identityMatches && version === extensionVersion,
+            });
+        }
+    }
+    return hits;
+}
+export async function inspectClineSurfaces(ctx) {
+    const [cli, extensions] = await Promise.all([
+        cliInstalledVersion(ctx.env),
+        extensionSurfaces(ctx),
+    ]);
+    return {
+        cliInstalled: cli.installed,
+        cliVersion: cli.version,
+        cliSupported: cli.installed && cli.version === cliVersion,
+        extensions,
+        extensionInstalled: extensions.length > 0,
+        extensionSupported: extensions.length > 0 && extensions.every(extension => extension.supported),
+    };
+}
+function assertSupportedVersions(surfaces) {
+    if (surfaces.cliInstalled && !surfaces.cliSupported) {
+        throw new Error(`Unsupported Cline CLI version ${surfaces.cliVersion || 'unknown'} detected. ScaleMax only writes the verified ${cliVersion} format; no configuration was changed.`);
+    }
+    const unsupportedExtensions = surfaces.extensions.filter(extension => !extension.supported);
+    if (unsupportedExtensions.length) {
+        const versions = unsupportedExtensions.map(extension => extension.version || 'unknown').join(', ');
+        throw new Error(`Unsupported Cline VS Code extension version(s) ${versions} detected. ScaleMax only writes the verified ${extensionVersion} format; no configuration was changed.`);
+    }
+    if (!surfaces.cliSupported && !surfaces.extensionSupported) {
+        throw new Error(`Cline CLI ${cliVersion} or the Cline VS Code extension ${extensionVersion} must be installed before configuration. No configuration was changed.`);
+    }
+}
+function shouldInspectProcesses(ctx) {
+    const nodeEnv = ctx.env.NODE_ENV || process.env.NODE_ENV;
+    return nodeEnv !== 'test' || ctx.env.SCALEMAX_FORCE_CLINE_PROCESS_CHECK === '1';
+}
+export function clineProcessConflicts(output, platform) {
+    if (platform === 'win32') {
+        return {
+            cli: /(^|[\r\n,"])cline\.exe(?:["\r\n,]|$)/i.test(output),
+            extension: /(^|[\r\n,"])code(?: - insiders)?\.exe(?:["\r\n,]|$)/i.test(output),
+        };
+    }
+    const lines = output.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+    return {
+        cli: lines.some(line => /(?:^|\/)cline(?:\s|$)/i.test(line.split(/\s+/, 1)[0] || '')),
+        extension: lines.some(line => /Visual Studio Code\.app|Code Helper|\/(?:usr\/share\/code|opt\/visual-studio-code)\/|(?:^|\s)code(?:\s|$)/i.test(line)),
+    };
+}
+async function assertProcessesStopped(ctx, surfaces) {
+    if (!shouldInspectProcesses(ctx))
+        return;
+    const command = ctx.platform === 'win32' ? 'tasklist' : '/bin/ps';
+    const args = ctx.platform === 'win32' ? ['/FO', 'CSV', '/NH'] : ['-ax', '-o', 'comm=', '-o', 'args='];
+    const result = await execa(command, args, {
+        env: ctx.env,
+        reject: false,
+        timeout: 5_000,
+        all: true,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`Could not verify that Cline is stopped (${result.all?.trim() || `${command} exited with ${result.exitCode}`}). No configuration was changed.`);
+    }
+    const conflicts = clineProcessConflicts(result.all || result.stdout || '', ctx.platform);
+    if (surfaces.cliSupported && conflicts.cli) {
+        throw new Error('Cline CLI is running. Exit Cline completely, then retry; no configuration was changed.');
+    }
+    if (surfaces.extensionSupported && conflicts.extension) {
+        throw new Error('VS Code is running. Exit every VS Code window completely, then retry Cline setup; no configuration was changed.');
+    }
+}
+function responseModels(ctx) {
+    return openAiResponsesModelIds(ctx).filter(modelId => modelSupportsTools(ctx, modelId));
+}
+function chatModels(ctx) {
+    return (ctx.models || [])
+        .map(model => model.id.trim())
+        .filter(modelId => modelId && modelSupportsTools(ctx, modelId));
+}
+function cliSelectedModel(ctx) {
+    const compatible = responseModels(ctx);
+    if (!compatible.length) {
+        throw new Error('Cline CLI 3.0.47 uses the Responses protocol, but this API key has no Responses-capable tool model. No configuration was changed.');
+    }
+    return preferredOpenAiResponsesModel({
+        ...ctx,
+        models: (ctx.models || []).filter(model => compatible.includes(model.id)),
+    });
+}
+function extensionSelectedModel(ctx) {
+    const compatible = chatModels(ctx);
+    if (!compatible.length) {
+        throw new Error('Cline requires native tool calling, but this API key has no available tool-capable models. No configuration was changed.');
+    }
+    return preferredChatCompletionsModel({
+        ...ctx,
+        models: (ctx.models || []).filter(model => compatible.includes(model.id)),
+    });
+}
+function cliSettings(ctx, model) {
+    return {
+        provider: cliProviderId,
+        apiKey: ctx.apiKey,
+        model,
+        protocol: 'openai-responses',
+        client: 'openai',
+        baseUrl: ctx.baseUrl.replace(/\/$/, ''),
+        capabilities: ['tools', 'streaming'],
+    };
+}
+function positiveInteger(value) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function extensionModelInfo(ctx, modelId) {
+    const source = (ctx.models || []).find(candidate => candidate.id === modelId);
+    return {
+        maxTokens: positiveInteger(source?.max_output_tokens) ?? -1,
+        contextWindow: positiveInteger(source?.context_window) ?? 128_000,
+        supportsImages: source?.capabilities?.images === true || source?.capabilities?.vision === true,
+        supportsPromptCache: source?.capabilities?.prompt_cache === true,
+        supportsReasoning: source?.capabilities?.reasoning === true,
+        supportsReasoningEffort: source?.capabilities?.reasoning_effort === true,
+        supportsTools: true,
+        supportsStreaming: true,
+        isR1FormatRequired: false,
+        inputPrice: 0,
+        outputPrice: 0,
+        temperature: 0,
+    };
+}
+function extensionGlobalState(ctx, current, model) {
+    const info = extensionModelInfo(ctx, model);
+    return {
+        ...current,
+        openAiBaseUrl: ctx.baseUrl.replace(/\/$/, ''),
+        openAiHeaders: {},
+        planModeApiProvider: 'openai',
+        actModeApiProvider: 'openai',
+        planModeOpenAiModelId: model,
+        actModeOpenAiModelId: model,
+        planModeOpenAiModelInfo: info,
+        actModeOpenAiModelInfo: info,
+    };
+}
+function sameJson(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function removeLegacyProvider(store) {
+    const legacy = store.providers?.[legacyProviderId];
+    if (legacy?.settings?.provider !== legacyProviderId
+        || !scaleMaxBaseUrl.test(String(legacy?.settings?.baseUrl || ''))) {
+        return { state: store, changed: false };
+    }
+    const providers = { ...store.providers };
+    delete providers[legacyProviderId];
+    const state = { ...store, providers };
+    if (state.lastUsedProvider === legacyProviderId)
+        delete state.lastUsedProvider;
+    return { state, changed: true };
+}
+function removeLegacyModels(store) {
+    const legacy = store?.providers?.[legacyProviderId];
+    if (!store || legacy?.provider?.name !== 'ScaleMax'
+        || !scaleMaxBaseUrl.test(String(legacy?.provider?.baseUrl || ''))) {
+        return { state: store, changed: false };
+    }
+    const providers = { ...store.providers };
+    delete providers[legacyProviderId];
+    return { state: { ...store, providers }, changed: true };
+}
+async function originalContents(files) {
+    return new Map(await Promise.all(files.map(async (file) => [
+        file,
+        await fs.readFile(file, 'utf8').catch(() => undefined),
+    ])));
+}
+async function rollbackFiles(originals, platform) {
+    for (const [file, original] of originals) {
+        if (original === undefined)
+            await fs.remove(file).catch(() => undefined);
+        else
+            await atomicWrite(file, original, 0o600, platform).catch(() => undefined);
+    }
+}
+async function writeTransaction(ctx, changes) {
+    const files = [...changes.keys()];
+    const originals = await originalContents(files);
+    for (const file of files)
+        await backupFile(file, ctx.home);
+    try {
+        for (const [file, state] of changes) {
+            await atomicWrite(file, JSON.stringify(state, null, 2) + '\n', 0o600, ctx.platform);
+        }
+    }
+    catch (error) {
+        await rollbackFiles(originals, ctx.platform);
+        throw error;
+    }
+}
+function assertRawCredential(apiKey) {
+    if (/^Bearer\s+/i.test(apiKey) || apiKey !== apiKey.trim()) {
+        throw new Error('Cline API Key must contain only the raw ScaleMax key; do not include a Bearer prefix or surrounding whitespace.');
+    }
+}
+export async function install(ctx) {
+    const surfaces = await inspectClineSurfaces(ctx);
+    if (surfaces.extensionSupported || surfaces.cliSupported) {
+        return {
+            id,
+            name,
+            changed: false,
+            message: surfaces.extensionSupported
+                ? `verified Cline VS Code extension ${extensionVersion} is already installed`
+                : `verified Cline CLI ${cliVersion} is already installed`,
+        };
+    }
+    if (!(await commandExists('code', ctx.env))) {
+        if (surfaces.cliInstalled || surfaces.extensionInstalled)
+            assertSupportedVersions(surfaces);
+        throw new Error(`VS Code was not detected. Install VS Code, then retry the pinned Cline ${extensionVersion} setup.`);
+    }
+    const result = await execa('code', ['--install-extension', `${extensionId}@${extensionVersion}`, '--force'], {
+        env: ctx.env,
+        reject: false,
+        all: true,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`Cline extension installation failed: ${result.all?.trim() || `code exited with ${result.exitCode}`}`);
+    }
+    const after = await inspectClineSurfaces(ctx);
+    if (!after.extensionSupported) {
+        throw new Error(`VS Code reported success, but Cline extension ${extensionVersion} could not be verified. No configuration was changed.`);
+    }
+    return { id, name, changed: true, message: `official Cline VS Code extension ${extensionVersion} installed and verified` };
+}
+export async function configure(ctx) {
+    assertRawCredential(ctx.apiKey);
+    const surfaces = await inspectClineSurfaces(ctx);
+    assertSupportedVersions(surfaces);
+    await assertProcessesStopped(ctx, surfaces);
+    const changes = new Map();
+    const configuredPaths = [];
+    if (surfaces.cliSupported) {
+        const providerFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+        const modelFile = legacyModelsPath(ctx);
+        const providers = await readProviderStore(providerFile);
+        const legacyCleaned = removeLegacyProvider(providers);
+        const model = cliSelectedModel(ctx);
+        const nextProviders = {
+            ...legacyCleaned.state,
+            lastUsedProvider: cliProviderId,
+            providers: {
+                ...legacyCleaned.state.providers,
+                [cliProviderId]: {
+                    settings: cliSettings(ctx, model),
+                    updatedAt: new Date().toISOString(),
+                    tokenSource: 'manual',
+                },
+            },
+        };
+        const existing = providers.providers?.[cliProviderId]?.settings;
+        const cliCurrent = sameJson(existing, cliSettings(ctx, model))
+            && providers.lastUsedProvider === cliProviderId
+            && !providers.providers?.[legacyProviderId];
+        if (!cliCurrent)
+            changes.set(providerFile, nextProviders);
+        configuredPaths.push(providerFile);
+        const legacyModels = await readLegacyModelStore(modelFile);
+        const cleanedModels = removeLegacyModels(legacyModels);
+        if (cleanedModels.changed && cleanedModels.state)
+            changes.set(modelFile, cleanedModels.state);
+    }
+    if (surfaces.extensionSupported) {
+        const { globalStateFile, secretsFile } = clineExtensionStatePaths(ctx);
+        const [globalState, secrets] = await Promise.all([
+            readObject(globalStateFile),
+            readObject(secretsFile),
+        ]);
+        const model = extensionSelectedModel(ctx);
+        const nextGlobalState = extensionGlobalState(ctx, globalState, model);
+        const nextSecrets = { ...secrets, openAiApiKey: ctx.apiKey };
+        if (!sameJson(globalState, nextGlobalState))
+            changes.set(globalStateFile, nextGlobalState);
+        if (!sameJson(secrets, nextSecrets))
+            changes.set(secretsFile, nextSecrets);
+        configuredPaths.push(globalStateFile, secretsFile);
+    }
+    if (!changes.size) {
+        for (const file of configuredPaths)
+            await fs.chmod(file, 0o600).catch(() => undefined);
+        return {
+            id,
+            name,
+            changed: false,
+            path: configuredPaths[0],
+            message: 'verified Cline configuration is already current',
+        };
+    }
+    await writeTransaction(ctx, changes);
+    return {
+        id,
+        name,
+        changed: true,
+        path: configuredPaths[0],
+        message: `configured ${surfaces.cliSupported ? `CLI ${cliVersion}` : ''}${surfaces.cliSupported && surfaces.extensionSupported ? ' and ' : ''}${surfaces.extensionSupported ? `VS Code extension ${extensionVersion}` : ''} with one raw ScaleMax credential; restart Cline to activate`,
+    };
+}
+function cliConfigurationValid(ctx, store) {
+    const model = cliSelectedModel(ctx);
+    return store.version === 1
+        && store.lastUsedProvider === cliProviderId
+        && sameJson(store.providers?.[cliProviderId]?.settings, cliSettings(ctx, model))
+        && store.providers?.[cliProviderId]?.settings?.headers === undefined
+        && store.providers?.[legacyProviderId] === undefined;
+}
+function extensionConfigurationValid(ctx, globalState, secrets) {
+    const model = extensionSelectedModel(ctx);
+    const expected = extensionGlobalState(ctx, globalState, model);
+    return sameJson(globalState, expected)
+        && secrets.openAiApiKey === ctx.apiKey
+        && !/^Bearer\s+/i.test(String(secrets.openAiApiKey || ''))
+        && sameJson(globalState.openAiHeaders, {});
+}
+async function assertPrivateFiles(files, platform) {
+    if (platform === 'win32')
+        return;
+    for (const file of files) {
+        if (((await fs.stat(file)).mode & 0o077) !== 0) {
+            throw new Error(`Cline configuration permissions are too broad: ${file}`);
+        }
+    }
+}
+export async function verify(ctx) {
+    assertRawCredential(ctx.apiKey);
+    const surfaces = await inspectClineSurfaces(ctx);
+    assertSupportedVersions(surfaces);
+    const files = [];
+    if (surfaces.cliSupported) {
+        const providerFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+        const providers = await readProviderStore(providerFile);
+        if (!cliConfigurationValid(ctx, providers)) {
+            throw new Error('Cline CLI ScaleMax configuration is incomplete or uses an unverified provider format.');
+        }
+        files.push(providerFile);
+    }
+    if (surfaces.extensionSupported) {
+        const { globalStateFile, secretsFile } = clineExtensionStatePaths(ctx);
+        const [globalState, secrets] = await Promise.all([
+            readObject(globalStateFile),
+            readObject(secretsFile),
+        ]);
+        if (!extensionConfigurationValid(ctx, globalState, secrets)) {
+            throw new Error('Cline VS Code ScaleMax configuration is incomplete or contains a custom authentication header.');
+        }
+        files.push(globalStateFile, secretsFile);
+    }
+    await assertPrivateFiles(files, ctx.platform);
+    return {
+        id,
+        name,
+        changed: false,
+        path: files[0],
+        message: `verified ${surfaces.cliSupported ? `CLI ${cliVersion}` : ''}${surfaces.cliSupported && surfaces.extensionSupported ? ' and ' : ''}${surfaces.extensionSupported ? `VS Code extension ${extensionVersion}` : ''} raw-key authentication with no custom auth header`,
+    };
+}
+export function isManagedCliStore(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const store = value;
+    const settings = store.providers?.[cliProviderId]?.settings;
+    return store.version === 1
+        && store.lastUsedProvider === cliProviderId
+        && settings?.provider === cliProviderId
+        && typeof settings?.apiKey === 'string'
+        && /^sm_(?:live|test)_/i.test(settings.apiKey)
+        && scaleMaxBaseUrl.test(String(settings?.baseUrl || ''))
+        && settings?.client === 'openai'
+        && settings?.protocol === 'openai-responses'
+        && settings?.headers === undefined
+        && store.providers?.[legacyProviderId] === undefined;
+}
+export function isManagedExtensionState(globalState, secrets) {
+    if (!globalState || typeof globalState !== 'object' || Array.isArray(globalState)
+        || !secrets || typeof secrets !== 'object' || Array.isArray(secrets))
+        return false;
+    const state = globalState;
+    const secretState = secrets;
+    return state.planModeApiProvider === 'openai'
+        && state.actModeApiProvider === 'openai'
+        && scaleMaxBaseUrl.test(String(state.openAiBaseUrl || ''))
+        && sameJson(state.openAiHeaders, {})
+        && typeof state.planModeOpenAiModelId === 'string'
+        && state.planModeOpenAiModelId.length > 0
+        && state.actModeOpenAiModelId === state.planModeOpenAiModelId
+        && state.planModeOpenAiModelInfo?.supportsTools === true
+        && state.planModeOpenAiModelInfo?.supportsStreaming === true
+        && state.actModeOpenAiModelInfo?.supportsTools === true
+        && state.actModeOpenAiModelInfo?.supportsStreaming === true
+        && typeof secretState.openAiApiKey === 'string'
+        && /^sm_(?:live|test)_/i.test(secretState.openAiApiKey)
+        && !/^Bearer\s+/i.test(secretState.openAiApiKey);
+}
+function deleteKeys(source, keys) {
+    const next = { ...source };
+    for (const key of keys)
+        delete next[key];
+    return next;
+}
+export async function remove(ctx) {
+    const surfaces = await inspectClineSurfaces(ctx);
+    if (!surfaces.cliInstalled && !surfaces.extensionInstalled) {
+        return { id, name, changed: false, message: 'Cline is not installed' };
+    }
+    assertSupportedVersions(surfaces);
+    await assertProcessesStopped(ctx, surfaces);
+    const changes = new Map();
+    let changed = false;
+    let resultPath;
+    if (surfaces.cliSupported) {
+        const providerFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+        if (await fs.pathExists(providerFile)) {
+            const providers = await readProviderStore(providerFile);
+            if (isManagedCliStore(providers)) {
+                const nextProviders = { ...providers.providers };
+                delete nextProviders[cliProviderId];
+                const next = { ...providers, providers: nextProviders };
+                delete next.lastUsedProvider;
+                changes.set(providerFile, next);
+                resultPath ||= providerFile;
+                changed = true;
+            }
+        }
+    }
+    if (surfaces.extensionSupported) {
+        const { globalStateFile, secretsFile } = clineExtensionStatePaths(ctx);
+        const [globalState, secrets] = await Promise.all([
+            readObject(globalStateFile),
+            readObject(secretsFile),
+        ]);
+        if (isManagedExtensionState(globalState, secrets)) {
+            const nextGlobal = deleteKeys(globalState, [
+                'openAiBaseUrl',
+                'openAiHeaders',
+                'planModeApiProvider',
+                'actModeApiProvider',
+                'planModeOpenAiModelId',
+                'actModeOpenAiModelId',
+                'planModeOpenAiModelInfo',
+                'actModeOpenAiModelInfo',
+            ]);
+            const nextSecrets = { ...secrets };
+            delete nextSecrets.openAiApiKey;
+            changes.set(globalStateFile, nextGlobal);
+            changes.set(secretsFile, nextSecrets);
+            resultPath ||= globalStateFile;
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return { id, name, changed: false, message: 'left unmanaged Cline configuration unchanged' };
+    }
+    await writeTransaction(ctx, changes);
+    return {
+        id,
+        name,
+        changed: true,
+        path: resultPath,
+        message: 'removed only ScaleMax-managed Cline authentication fields',
+    };
+}

package/dist/configure/paths.js

@@ -10,6 +10,14 @@ export function clientConfigPath(id, home, platform, env = process.env) {
         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 'roo-code': 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 'cline': {
+            const explicit = env.CLINE_PROVIDER_SETTINGS_PATH?.trim();
+            if (explicit)
+                return explicit;
+            const dataDir = env.CLINE_DATA_DIR?.trim()
+                || path.join(env.CLINE_DIR?.trim() || path.join(home, '.cline'), 'data');
+            return path.join(dataDir, 'settings', 'providers.json');
+        }
         case 'continue': return path.join(home, '.continue', 'config.yaml');
         case 'trae-solo': return path.join(home, '.scalemax', 'trae-solo.setup.json');
         case 'claude': return path.join(home, '.claude', 'settings.json');
@@ -27,6 +35,7 @@ export function installHints(id, home, platform, env = process.env) {
         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 'roo-code': return [path.join(home, '.vscode', 'extensions'), path.join(home, '.vscode-insiders', 'extensions')];
+        case 'cline': return [path.join(home, '.vscode', 'extensions'), path.join(home, '.vscode-insiders', 'extensions')];
         case 'continue': return [path.join(home, '.vscode', 'extensions'), path.join(home, '.vscode-insiders', 'extensions')];
         case 'trae-solo': return [platform === 'darwin' ? '/Applications/Trae.app' : path.join(app, 'Trae'), path.join(linux, 'Trae')];
         case 'claude': return [path.join(home, '.claude')];

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,62 @@
+import fs from 'fs-extra';
+import { clientConfigPath } from '../configure/paths.js';
+import { clineExtensionStatePaths, inspectClineSurfaces, isManagedCliStore, isManagedExtensionState, } from '../configure/cline.js';
+import { commandExists } from '../utils/exec.js';
+const id = 'cline';
+const name = 'Cline';
+export async function detect(ctx) {
+    const surfaces = await inspectClineSurfaces(ctx);
+    const paths = [];
+    const configuredSurfaces = [];
+    if (surfaces.cliInstalled) {
+        paths.push(`command:cline${surfaces.cliVersion ? `@${surfaces.cliVersion}` : ''}`);
+        if (surfaces.cliSupported) {
+            const providerFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+            const configured = isManagedCliStore(await fs.readJson(providerFile).catch(() => undefined));
+            configuredSurfaces.push(configured);
+            if (configured)
+                paths.push(providerFile);
+        }
+        else {
+            configuredSurfaces.push(false);
+        }
+    }
+    for (const extension of surfaces.extensions)
+        paths.push(extension.path);
+    if (surfaces.extensionInstalled) {
+        if (surfaces.extensionSupported) {
+            const { globalStateFile, secretsFile } = clineExtensionStatePaths(ctx);
+            const [globalState, secrets] = await Promise.all([
+                fs.readJson(globalStateFile).catch(() => undefined),
+                fs.readJson(secretsFile).catch(() => undefined),
+            ]);
+            const configured = isManagedExtensionState(globalState, secrets);
+            configuredSurfaces.push(configured);
+            if (configured)
+                paths.push(globalStateFile, secretsFile);
+        }
+        else {
+            configuredSurfaces.push(false);
+        }
+    }
+    const installed = surfaces.cliInstalled || surfaces.extensionInstalled;
+    const configured = installed && configuredSurfaces.length > 0 && configuredSurfaces.every(Boolean);
+    const unsupported = [];
+    if (surfaces.cliInstalled && !surfaces.cliSupported)
+        unsupported.push(`CLI ${surfaces.cliVersion || 'unknown'} (requires 3.0.47)`);
+    for (const extension of surfaces.extensions.filter(candidate => !candidate.supported)) {
+        unsupported.push(`VS Code extension ${extension.version || 'unknown'} (requires 4.0.12)`);
+    }
+    return {
+        id,
+        name,
+        installed,
+        configured,
+        executable: surfaces.cliInstalled,
+        installable: await commandExists('code', ctx.env),
+        reason: unsupported.length
+            ? `Unsupported Cline surface detected: ${unsupported.join(', ')}`
+            : installed ? undefined : 'Cline CLI and VS Code extension were not detected',
+        paths,
+    };
+}

package/dist/detect/common.js

@@ -3,7 +3,7 @@ import { commandExists } from '../utils/exec.js';
 import { clientConfigPath, installHints } from '../configure/paths.js';
 import { GENERATED_HEADER } from '../constants.js';
 const commands = {
-    codex: ['codex'], cursor: ['cursor'], 'roo-code': ['code'], continue: ['code'], 'trae-solo': ['trae', 'trae-solo'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], 'cherry-studio': ['cherry-studio', 'cherrystudio'], 'api-code': []
+    codex: ['codex'], cursor: ['cursor'], 'roo-code': ['code'], cline: ['cline'], continue: ['code'], 'trae-solo': ['trae', 'trae-solo'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], 'cherry-studio': ['cherry-studio', 'cherrystudio'], 'api-code': []
 };
 const guiPathDetection = new Set(['trae-solo', 'cherry-studio']);
 function hasNativeScaleMaxConfig(id, text) {

package/dist/types/client.d.ts

@@ -1,4 +1,4 @@
-export type ClientId = 'codex' | 'cursor' | 'roo-code' | 'continue' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
+export type ClientId = 'codex' | 'cursor' | 'roo-code' | 'cline' | 'continue' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
 export type ProviderScope = 'openai' | 'anthropic' | 'both' | 'deepseek-v4-flash' | 'glm-5.2';
 export interface ClientDefinition {
     id: ClientId;

package/package.json

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