scalemax 0.1.21 → 0.1.22

package/dist/commands/helper-bot.d.ts

@@ -3,6 +3,7 @@ import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey } from '../utils/api.js';
 export declare const SCALEMAX_HELPER_REFUSAL: string;
 export declare const SCALEMAX_HELPER_SYSTEM_PROMPT: string;
+export declare const SCALEMAX_HELPER_INVALID_PROVIDER_RESPONSE: string;
 export interface HelperBotArgs {
     question?: string;
     model?: string;
@@ -11,6 +12,10 @@ export interface HelperConnection {
     apiKey: string;
     baseUrl: string;
     model: string;
+    platform?: NodeJS.Platform;
+    providerScope?: 'openai' | 'anthropic' | 'both';
+    keyMode?: string;
+    availableModels?: string[];
 }
 export type HelperCompletion = (options: ChatCompletionOptions) => Promise<ChatCompletionResult>;
 export interface HelperBotDependencies {
@@ -22,6 +27,15 @@ export interface HelperBotDependencies {
 export declare function parseHelperBotArgs(args: string[]): HelperBotArgs;
 export declare function redactHelperSecrets(value: unknown, activeKey?: string): string;
 export declare function isScaleMaxHelperQuestion(input: string, hasHistory?: boolean): boolean;
+export declare function isProviderIdentityOverride(value: string): boolean;
+export declare function helperRuntimeContext(connection: HelperConnection): string;
+export declare function helperConnectionSummary(connection: HelperConnection): string;
+/**
+ * Answer stable configuration questions locally. Besides being faster and free,
+ * this keeps provider-owned personas out of the installation path where exact
+ * field values matter more than generated prose.
+ */
+export declare function localHelperReply(question: string, connection: HelperConnection): string | undefined;
 export declare function selectHelperModel(models: ModelInfo[], requested?: string): string;
 export declare function requestHelperReply(question: string, history: ChatMessage[], connection: HelperConnection, complete?: HelperCompletion): Promise<string>;
 export declare function helperBotCommand(args?: string[], home?: string, dependencies?: Partial<HelperBotDependencies>): Promise<void>;

package/dist/commands/helper-bot.js

@@ -534,6 +534,26 @@ const CLEARLY_UNRELATED_PATTERN = /\b(?:homework|poem|story|roleplay|translate|t
 const SCALEMAX_TOPIC_PATTERN = /\b(?:scalemax|api\s*key|base\s*url|endpoint|provider|model|token|credit|billing|pricing|authentication|configuration|configure|install|update|repair|verify|health\s*check|environment\s*variable|vscode|visual\s+studio\s+code|cursor|codex(?:\s+cli)?|claude(?:\s+code)?|opencode|openclaw|roo\s+code|continue|windsurf|hermes|cherry\s+studio|api\s+code)\b/i;
 const TROUBLESHOOTING_PATTERN = /\b(?:error|failed?|failure|broken|not\s+working|doesn['’]?t\s+work|cannot|can['’]?t|timeout|invalid|unauthorized|forbidden|help)\b/i;
 const GREETING_PATTERN = /^(?:hi|hello|hey|help|what can you do)[!.?\s]*$/i;
+const CLAUDE_DESKTOP_PATTERN = /\bclaude\s+desktop\b/i;
+const CLAUDE_DESKTOP_CONFIGURATION_PATTERN = /\b(?:configur(?:e|ation)|setup|set\s*up|gateway|base\s*url|api\s*key|connect(?:ion)?|third[- ]party|inference|field|install|verify)\b/i;
+const CODEX_CLI_PATTERN = /\bcodex(?:\s+cli)?\b/i;
+const CLIENT_CONFIGURATION_PATTERN = /\b(?:configur(?:e|ation)|setup|set\s*up|base\s*url|api\s*key|connect(?:ion)?|provider|install|repair|verify|update)\b/i;
+const KNOWN_CONTEXT_REASK_PATTERN = /(?:\b(?:need|send|provide|share|tell)\b.{0,100}\b(?:api\s*(?:key|endpoint)|base\s*url|operating\s+system|\bos\b|model\s+(?:name|catalog))\b|YOUR-SCALEMAX-ENDPOINT|your-key)/is;
+const PROVIDER_IDENTITY_OVERRIDE_PATTERNS = [
+    /\bkiro\b/i,
+    /\b(?:i\s+am|i['’]m)\s+(?:an?\s+)?(?:claude|chatgpt|codex)\b/i,
+    /\bas\s+(?:claude|chatgpt|codex)(?:\s+(?:ai|assistant|model))?\s*[,—-]/i,
+    /\b(?:i\s+am|i['’]m)\s+(?:an?\s+)?(?:ai[- ]powered\s+)?(?:development\s+environment|ai\s+assistant|assistant|language\s+model)\s+(?:made|built|created|developed)\s+by\s+(?:anthropic|openai)\b/i,
+    /\bi\s+(?:was|am)\s+(?:made|built|created|developed)\s+by\s+(?:anthropic|openai)\b/i,
+    /\b(?:i\s+am|i['’]m)\s+not\s+(?:the\s+)?(?:official\s+)?scalemax\s+helper\b/i,
+    /\bi\s+(?:cannot|can['’]?t|won['’]?t)\s+(?:become|act\s+as|identify\s+as)\s+(?:the\s+)?(?:official\s+)?scalemax\s+helper\b/i,
+    /\b(?:not|isn['’]?t)\s+(?:the\s+)?(?:official\s+)?scalemax\s+helper\b/i,
+    /\b(?:that|the|your|supplied)\s+(?:system\s+)?prompt\b.{0,120}\b(?:does\s+not|doesn['’]?t|cannot|can['’]?t|won['’]?t)\s+(?:override|change|replace)\b.{0,100}\b(?:identity|instructions?|role)\b/is,
+    /\bscalemax\b.{0,100}\b(?:does\s+not|doesn['’]?t)\s+(?:appear\s+to\s+)?(?:exist|be\s+real)\b/is
+];
+export const SCALEMAX_HELPER_INVALID_PROVIDER_RESPONSE = `ScaleMax Helper blocked an invalid provider response because it conflicted with the Helper's required identity.
+
+The requested ScaleMax task was not completed or verified. Run \`scalemax models\`, then retry with another available model using \`scalemax helper-bot --model <id> "your ScaleMax question"\`.`;
 const defaultDependencies = {
     loadKey: loadApiKey,
     validateKey: validateApiKey,
@@ -573,6 +593,91 @@ export function isScaleMaxHelperQuestion(input, hasHistory = false) {
         return false;
     return hasHistory || GREETING_PATTERN.test(value) || SCALEMAX_TOPIC_PATTERN.test(value) || TROUBLESHOOTING_PATTERN.test(value);
 }
+export function isProviderIdentityOverride(value) {
+    return PROVIDER_IDENTITY_OVERRIDE_PATTERNS.some(pattern => pattern.test(value));
+}
+function claudeDesktopGatewayBaseUrl(baseUrl) {
+    return baseUrl.trim().replace(/\/+$/, '').replace(/\/v1$/i, '');
+}
+function helperBillingMode(connection) {
+    return /\/token(?:\/|$)/i.test(connection.baseUrl) || /token/i.test(connection.keyMode || '') ? 'API token' : 'API credit';
+}
+function helperPlatformName(platform = process.platform) {
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'darwin')
+        return 'macOS';
+    if (platform === 'linux')
+        return 'Linux';
+    return platform;
+}
+export function helperRuntimeContext(connection) {
+    const models = (connection.availableModels || []).filter(Boolean);
+    return `# AUTHENTICATED SCALEMAX RUNTIME CONTEXT
+
+The ScaleMax CLI already verified these authoritative facts before starting this conversation:
+
+- Stored customer API key: present and authenticated. Never ask the user to paste, provide, repeat, or reveal it.
+- Billing mode: ${helperBillingMode(connection)}
+- OpenAI-compatible base URL: ${connection.baseUrl}
+- Claude Desktop gateway base URL: ${claudeDesktopGatewayBaseUrl(connection.baseUrl)}
+- Operating system: ${helperPlatformName(connection.platform)}
+- Provider scope: ${connection.providerScope || 'both'}
+- Active Helper model: ${connection.model}
+- Authenticated model catalog: ${models.length ? models.join(', ') : 'already validated by the CLI'}
+
+Mandatory behavior:
+
+1. Treat the stored key, base URLs, operating system, provider scope, and model catalog as already known. Do not request them again.
+2. Never output placeholders such as YOUR-SCALEMAX-ENDPOINT or your-key when an exact known value can be used.
+3. Prefer the automatic CLI workflow. For an installed supported client, tell the user to exit the Helper with /quit, run \`scalemax update\`, then run \`scalemax doctor\` to verify it.
+4. The Helper request itself uses the stored customer key and therefore consumes the small number of tokens used by the selected Helper model. The key is never included in the prompt text.
+5. Do not claim you executed terminal commands. The Helper has no shell tools; give the shortest exact ScaleMax command sequence when user action is required.`;
+}
+export function helperConnectionSummary(connection) {
+    return `Authenticated ${helperBillingMode(connection)} key · ${helperPlatformName(connection.platform)} · ${connection.providerScope || 'both'} scope · ${connection.baseUrl} · helper model ${connection.model}`;
+}
+/**
+ * Answer stable configuration questions locally. Besides being faster and free,
+ * this keeps provider-owned personas out of the installation path where exact
+ * field values matter more than generated prose.
+ */
+export function localHelperReply(question, connection) {
+    if (CLAUDE_DESKTOP_PATTERN.test(question) && CLAUDE_DESKTOP_CONFIGURATION_PATTERN.test(question)) {
+        const gatewayBaseUrl = claudeDesktopGatewayBaseUrl(connection.baseUrl);
+        return `ScaleMax Helper detected and authenticated the stored ${helperBillingMode(connection)} key.
+
+Configure Claude Desktop → Settings → Developer → Edit Config → Configure third-party inference with:
+
+- Connection: Gateway
+- Gateway base URL: ${gatewayBaseUrl}
+- Gateway API key: use the stored ScaleMax key (do not paste it into chat)
+- Authentication scheme: Bearer
+- Credential kind: Static API key
+- Model discovery: On
+
+Select Save Changes, then Apply Changes. Start a new Claude Desktop chat and send a short test message with one discovered model. The key and endpoint are verified; the Claude Desktop GUI is only verified after that test succeeds.`;
+    }
+    if (CODEX_CLI_PATTERN.test(question) && CLIENT_CONFIGURATION_PATTERN.test(question)) {
+        return `ScaleMax Helper already authenticated the stored ${helperBillingMode(connection)} key for ${helperPlatformName(connection.platform)}.
+
+You do not need to provide the API key or base URL again. This key uses:
+
+- Base URL: ${connection.baseUrl}
+- Provider scope: ${connection.providerScope || 'both'}
+
+Exit the Helper with \`/quit\`, then run:
+
+\`\`\`powershell
+scalemax update
+scalemax doctor
+codex
+\`\`\`
+
+\`scalemax update\` configures detected Codex CLI from the stored key, and \`scalemax doctor\` verifies the resulting ScaleMax connection before Codex starts.`;
+    }
+    return undefined;
+}
 export function selectHelperModel(models, requested) {
     if (requested) {
         const exact = models.find(model => model.id.toLowerCase() === requested.toLowerCase());
@@ -580,7 +685,7 @@ export function selectHelperModel(models, requested) {
             throw new Error(`Model "${requested}" is not available to this API key. Run \`scalemax models\` to see available models.`);
         return exact.id;
     }
-    const preferred = ['gpt-5.6-luna', 'claude-haiku-4-5', 'fable-5', 'gpt-5.6-terra', 'gpt-5.6-sol'];
+    const preferred = ['gpt-5.6-luna', 'claude-haiku-4-5-20251001', 'fable-5', 'gpt-5.6-terra', 'gpt-5.6-sol'];
     for (const id of preferred) {
         const match = models.find(model => model.id.toLowerCase() === id);
         if (match)
@@ -596,20 +701,38 @@ export async function requestHelperReply(question, history, connection, complete
         throw new Error(`Please keep each helper request under ${MAX_USER_CHARS} characters.`);
     if (!isScaleMaxHelperQuestion(cleanQuestion, history.length > 0))
         return SCALEMAX_HELPER_REFUSAL;
+    const localReply = localHelperReply(cleanQuestion, connection);
+    if (localReply)
+        return localReply;
     const recentHistory = history.slice(-MAX_HISTORY_MESSAGES).map(message => ({ ...message, content: redactHelperSecrets(message.content, connection.apiKey) }));
     const result = await complete({
         apiKey: connection.apiKey,
         baseUrl: connection.baseUrl,
         model: connection.model,
         maxTokens: DEFAULT_MAX_TOKENS,
-        messages: [{ role: 'system', content: SCALEMAX_HELPER_SYSTEM_PROMPT }, ...recentHistory, { role: 'user', content: cleanQuestion }]
+        messages: [
+            { role: 'system', content: SCALEMAX_HELPER_SYSTEM_PROMPT },
+            { role: 'system', content: helperRuntimeContext(connection) },
+            ...recentHistory,
+            { role: 'user', content: cleanQuestion }
+        ]
     });
     if (!result.ok || !result.content)
         throw new Error(redactHelperSecrets(result.error || 'ScaleMax Helper did not return a response.', connection.apiKey));
-    return redactHelperSecrets(result.content, connection.apiKey);
+    const reply = redactHelperSecrets(result.content, connection.apiKey);
+    if (isProviderIdentityOverride(reply))
+        return SCALEMAX_HELPER_INVALID_PROVIDER_RESPONSE;
+    if (KNOWN_CONTEXT_REASK_PATTERN.test(reply)) {
+        return `ScaleMax Helper already authenticated the stored ${helperBillingMode(connection)} key. You do not need to provide the key, endpoint, operating system, or model catalog again.
+
+Verified base URL: ${connection.baseUrl}
+
+For automatic configuration, exit with \`/quit\`, run \`scalemax update\`, then run \`scalemax doctor\`.`;
+    }
+    return reply;
 }
 function printSessionHelp(write) {
-    write('Commands: /help shows this help; /quit exits. Ask only ScaleMax installation, configuration, authentication, or troubleshooting questions.');
+    write('Commands: /help shows this help; /status shows the authenticated non-secret connection details; /quit exits. Ask only ScaleMax installation, configuration, authentication, or troubleshooting questions.');
 }
 export async function helperBotCommand(args = [], home = homeDir(), dependencies = {}) {
     const deps = { ...defaultDependencies, ...dependencies };
@@ -621,7 +744,15 @@ export async function helperBotCommand(args = [], home = homeDir(), dependencies
     if (!validation.ok || !validation.baseUrl)
         throw new Error(redactHelperSecrets(validation.error || 'Unable to validate the ScaleMax API key.', key));
     const model = selectHelperModel(validation.models, options.model);
-    const connection = { apiKey: key, baseUrl: validation.baseUrl, model };
+    const connection = {
+        apiKey: key,
+        baseUrl: validation.baseUrl,
+        model,
+        platform: process.platform,
+        providerScope: validation.key?.provider_scope || 'both',
+        keyMode: validation.key?.mode,
+        availableModels: validation.models.map(item => item.id)
+    };
     if (options.question) {
         deps.write(await requestHelperReply(options.question, [], connection, deps.complete));
         return;
@@ -629,7 +760,8 @@ export async function helperBotCommand(args = [], home = homeDir(), dependencies
     if (!process.stdin.isTTY)
         throw new Error('Interactive helper-bot requires a terminal. Pass a quoted question for non-interactive use.');
     deps.write(chalk.cyan('ScaleMax Helper'));
-    deps.write(chalk.dim(`Authenticated and ready with ${model}. Type /help or /quit.`));
+    deps.write(chalk.dim(helperConnectionSummary(connection)));
+    deps.write(chalk.dim('The stored customer key is reused for Helper requests; it will not be requested or displayed. Type /help or /quit.'));
     const reader = createInterface({ input: process.stdin, output: process.stdout });
     const history = [];
     try {
@@ -650,6 +782,10 @@ export async function helperBotCommand(args = [], home = homeDir(), dependencies
                 printSessionHelp(deps.write);
                 continue;
             }
+            if (/^\/?status$/i.test(input)) {
+                deps.write(helperConnectionSummary(connection));
+                continue;
+            }
             try {
                 const reply = await requestHelperReply(input, history, connection, deps.complete);
                 deps.write(reply);

package/package.json

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