scalemax 0.1.47 → 0.1.48

package/dist/commands/helper-bot.js

@@ -714,7 +714,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.4', 'gpt-5.4-mini', 'claude-haiku-4-5-20251001', '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)

package/dist/configure/codex.d.ts

@@ -6,7 +6,23 @@ export interface CodexVerificationResult {
     configPath: string;
     authPath: string;
 }
-export declare function mergeCodexConfig(existing: string, baseUrl: string, model?: string, authHash?: string): string;
+export declare function mergeCodexConfig(existing: string, baseUrl: string, model?: string, authHash?: string, keyHash?: string): string;
+/**
+ * Take ScaleMax OUT of a config.toml, keeping everything else the user has --
+ * including what Codex or the user added after setup (trusted projects,
+ * notices, other providers).
+ *
+ * Ownership is read from the CONTENT, not only from the generated header: a
+ * Codex rewrite that drops comments still leaves `model_provider = "scalemax"`
+ * and the `[model_providers.scalemax]` table, and those must go. The three
+ * top-level keys are removed only while ScaleMax is still the provider; if the
+ * user switched provider after setup they are the user's.
+ */
+export declare function stripScaleMaxCodexConfig(existing: string): {
+    text: string;
+    found: boolean;
+    strippedTopLevel: boolean;
+};
 export declare function verifyCodexConfiguration(ctx: ConfigureContext): Promise<CodexVerificationResult>;
 export declare function install(ctx: InstallContext): Promise<ConfigureResult>;
 export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/codex.js

@@ -10,17 +10,29 @@ import { AUTO_MODEL_ID, preferredOpenAiResponsesModel } from './models.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
-const fallbackModel = 'gpt-5.5';
+const fallbackModel = 'gpt-5.6-luna'; // gpt-5.5 retired 2026-09-30; same price
 const reasoningEffort = 'medium';
 const managedAuthHashPrefix = '# ScaleMax managed auth.json SHA-256: ';
+// Fingerprint of the API key setup wrote into auth.json. Unlike the auth.json
+// hash above it survives Codex rewriting auth.json (a token refresh, its own
+// serialisation), so remove() can still tell OUR key from one the user put
+// there later.
+const managedKeyHashPrefix = '# ScaleMax managed API key SHA-256: ';
+const modelsComment = '# ScaleMax models are loaded from the authenticated live model catalog.';
+// The top-level keys setup owns while ScaleMax is the provider. remove() puts
+// the user's pre-ScaleMax values for exactly these back from the backup.
+const managedTopLevelKey = /^(model|model_provider|model_reasoning_effort)\s*=/;
 function contentSha256(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
-function managedAuthHash(config) {
-    const marker = config.split(/\r?\n/).find(line => line.startsWith(managedAuthHashPrefix));
-    const hash = marker?.slice(managedAuthHashPrefix.length).trim();
+function markerHash(config, prefix) {
+    const marker = config.split(/\r?\n/).find(line => line.startsWith(prefix));
+    const hash = marker?.slice(prefix.length).trim();
     return hash && /^[a-f0-9]{64}$/.test(hash) ? hash : undefined;
 }
+function managedAuthHash(config) {
+    return markerHash(config, managedAuthHashPrefix);
+}
 function selectedModel(ctx) {
     if (!ctx.models) {
         // An auto-api key's ONLY model is `auto`; gpt-5.5 (the generic fallback
@@ -30,11 +42,22 @@ function selectedModel(ctx) {
     }
     return preferredOpenAiResponsesModel(ctx);
 }
-function scalemaxCodexBlock(baseUrl, model = fallbackModel, authHash) {
+function scalemaxCodexBlock(baseUrl, model = fallbackModel, authHash, keyHash) {
     const authMarker = authHash ? `${managedAuthHashPrefix}${authHash}\n` : '';
-    return `# ${GENERATED_HEADER}\n${authMarker}model = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n# ScaleMax models are loaded from the authenticated live model catalog.\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+    const keyMarker = keyHash ? `${managedKeyHashPrefix}${keyHash}\n` : '';
+    return `# ${GENERATED_HEADER}\n${authMarker}${keyMarker}model = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n${modelsComment}\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
+}
+/** A line setup writes as a comment. Never user content, and never preserved. */
+function isManagedCommentLine(line) {
+    return line === `# ${GENERATED_HEADER}`
+        || line === modelsComment
+        || line.startsWith(managedAuthHashPrefix)
+        || line.startsWith(managedKeyHashPrefix);
 }
-export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authHash) {
+function isScaleMaxProviderSection(section) {
+    return section === `model_providers.${provider}` || section.startsWith(`model_providers.${provider}.`);
+}
+export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authHash, keyHash) {
     const preserved = [];
     let section = '';
     let skipScaleMaxProvider = false;
@@ -43,20 +66,94 @@ export function mergeCodexConfig(existing, baseUrl, model = fallbackModel, authH
         const sectionMatch = line.match(/^\[([^\]]+)\]$/);
         if (sectionMatch) {
             section = sectionMatch[1];
-            skipScaleMaxProvider = section === `model_providers.${provider}`;
+            skipScaleMaxProvider = isScaleMaxProviderSection(section);
             if (skipScaleMaxProvider)
                 continue;
         }
         if (skipScaleMaxProvider)
             continue;
-        if (!section && /^(model|model_provider|model_reasoning_effort)\s*=/.test(line))
+        if (!section && managedTopLevelKey.test(line))
             continue;
-        if (line === `# ${GENERATED_HEADER}` || line.startsWith(managedAuthHashPrefix))
+        // Includes the models comment: it used to be kept here, so every re-run of
+        // setup stacked one more copy of it into the preserved tail.
+        if (isManagedCommentLine(line))
             continue;
         preserved.push(raw);
     }
     const tail = preserved.join('\n').trim();
-    return `${scalemaxCodexBlock(baseUrl, model, authHash)}${tail ? `\n${tail}\n` : ''}`;
+    return `${scalemaxCodexBlock(baseUrl, model, authHash, keyHash)}${tail ? `\n${tail}\n` : ''}`;
+}
+/**
+ * Take ScaleMax OUT of a config.toml, keeping everything else the user has --
+ * including what Codex or the user added after setup (trusted projects,
+ * notices, other providers).
+ *
+ * Ownership is read from the CONTENT, not only from the generated header: a
+ * Codex rewrite that drops comments still leaves `model_provider = "scalemax"`
+ * and the `[model_providers.scalemax]` table, and those must go. The three
+ * top-level keys are removed only while ScaleMax is still the provider; if the
+ * user switched provider after setup they are the user's.
+ */
+export function stripScaleMaxCodexConfig(existing) {
+    const lines = existing.split(/\r?\n/);
+    let section = '';
+    let topProvider;
+    let found = false;
+    for (const raw of lines) {
+        const line = raw.trim();
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            if (isScaleMaxProviderSection(section))
+                found = true;
+            continue;
+        }
+        if (isManagedCommentLine(line))
+            found = true;
+        if (!section) {
+            const providerMatch = line.match(/^model_provider\s*=\s*"([^"]*)"/);
+            if (providerMatch)
+                topProvider = providerMatch[1];
+        }
+    }
+    const strippedTopLevel = topProvider === provider;
+    if (strippedTopLevel)
+        found = true;
+    if (!found)
+        return { text: existing, found: false, strippedTopLevel: false };
+    const kept = [];
+    section = '';
+    let skip = false;
+    for (const raw of lines) {
+        const line = raw.trim();
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            skip = isScaleMaxProviderSection(section);
+            if (skip)
+                continue;
+        }
+        if (skip)
+            continue;
+        if (!section && strippedTopLevel && managedTopLevelKey.test(line))
+            continue;
+        if (isManagedCommentLine(line))
+            continue;
+        kept.push(raw);
+    }
+    return { text: kept.join('\n').trim(), found: true, strippedTopLevel };
+}
+/** The pre-ScaleMax top-level model / model_provider / model_reasoning_effort lines of a backup. */
+function originalTopLevelLines(backup) {
+    const out = [];
+    for (const raw of backup.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (/^\[[^\]]+\]$/.test(line))
+            break;
+        if (managedTopLevelKey.test(line))
+            out.push(line);
+    }
+    return out;
 }
 function codexAuth(apiKey, existing = {}) {
     return JSON.stringify({ ...existing, auth_mode: 'apikey', OPENAI_API_KEY: apiKey }, null, 2) + '\n';
@@ -111,22 +208,99 @@ async function latestRestorableBackup(file, home) {
     }
     return undefined;
 }
-async function restoreOrRemove(file, ctx, managedOverride) {
+async function removeCodexConfig(file, ctx) {
     if (!(await fs.pathExists(file)))
         return { changed: false, message: 'no ScaleMax configuration found' };
     const current = await fs.readFile(file, 'utf8').catch(() => '');
-    const structurallyManaged = current.includes(GENERATED_HEADER)
-        || (file.endsWith('auth.json') && isManagedCodexAuth(current));
-    const managed = managedOverride ?? structurallyManaged;
-    if (!managed)
+    const stripped = stripScaleMaxCodexConfig(current);
+    if (!stripped.found)
+        return { changed: false, message: 'left unmanaged configuration unchanged' };
+    // Put back the user's own model settings from before setup (the first
+    // pre-ScaleMax backup) -- only when ScaleMax's were actually taken out.
+    let restoredTop = [];
+    if (stripped.strippedTopLevel) {
+        const backup = await latestRestorableBackup(file, ctx.home);
+        if (backup)
+            restoredTop = originalTopLevelLines(await fs.readFile(backup, 'utf8').catch(() => ''));
+    }
+    const next = [restoredTop.join('\n'), stripped.text].filter(Boolean).join('\n\n');
+    if (!next.trim()) {
+        await fs.remove(file);
+        return { changed: true, message: 'removed ScaleMax configuration' };
+    }
+    await atomicWrite(file, `${next}\n`, 0o600, ctx.platform);
+    return {
+        changed: true,
+        message: restoredTop.length
+            ? 'removed ScaleMax settings and restored your previous model settings'
+            : 'removed ScaleMax settings; your other settings were kept',
+    };
+}
+/**
+ * Take the ScaleMax credential OUT of auth.json.
+ *
+ * Owned when ANY of: the file is byte-identical to what setup wrote (auth
+ * hash marker); its key is the key the CLI has saved; its key matches the
+ * key fingerprint setup wrote into config.toml. The last two survive Codex
+ * rewriting the file -- a ChatGPT token refresh or its own serialisation --
+ * which the exact hash alone did not, and which left the ScaleMax key in
+ * place after "remove". A DIFFERENT key the user put there after setup is
+ * none of these, and is left alone.
+ *
+ * Only the two fields setup sets are touched: auth_mode and OPENAI_API_KEY go
+ * back to their pre-setup values from the backup, or away if there were none.
+ * Tokens and refresh times stay as Codex last wrote them (they are fresher
+ * than the backup). A file left with nothing in it is deleted.
+ */
+async function removeCodexAuth(file, ctx, ownership) {
+    if (!(await fs.pathExists(file)))
+        return { changed: false, message: 'no ScaleMax configuration found' };
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    let current;
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('not an object');
+        current = parsed;
+    }
+    catch {
         return { changed: false, message: 'left unmanaged configuration unchanged' };
-    const restore = await latestRestorableBackup(file, ctx.home);
-    if (restore) {
-        await atomicWrite(file, await fs.readFile(restore, 'utf8'), 0o600, ctx.platform);
-        return { changed: true, message: `restored backup ${restore}` };
     }
-    await fs.remove(file);
-    return { changed: true, message: 'removed ScaleMax configuration' };
+    const key = typeof current.OPENAI_API_KEY === 'string' ? current.OPENAI_API_KEY : undefined;
+    const owned = (ownership.authHash !== undefined && contentSha256(text) === ownership.authHash)
+        || (key !== undefined && typeof ctx.apiKey === 'string' && ctx.apiKey.length > 0 && key === ctx.apiKey)
+        || (key !== undefined && ownership.keyHash !== undefined && contentSha256(key) === ownership.keyHash)
+        || (ownership.authHash === undefined && ownership.keyHash === undefined && ownership.legacyStructural && isManagedCodexAuth(text));
+    if (!owned)
+        return { changed: false, message: 'left unmanaged configuration unchanged' };
+    let original;
+    const backup = await latestRestorableBackup(file, ctx.home);
+    if (backup) {
+        try {
+            const parsed = JSON.parse(await fs.readFile(backup, 'utf8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                original = parsed;
+        }
+        catch { /* an unreadable backup restores nothing */ }
+    }
+    const next = { ...current };
+    for (const field of ['auth_mode', 'OPENAI_API_KEY']) {
+        if (original && Object.prototype.hasOwnProperty.call(original, field))
+            next[field] = original[field];
+        else
+            delete next[field];
+    }
+    const meaningful = Object.values(next).some(value => value !== null && value !== undefined
+        && !(typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0));
+    if (!original && !meaningful) {
+        await fs.remove(file);
+        return { changed: true, message: 'removed ScaleMax configuration' };
+    }
+    await atomicWrite(file, JSON.stringify(next, null, 2) + '\n', 0o600, ctx.platform);
+    return {
+        changed: true,
+        message: original ? 'removed the ScaleMax key and restored your previous sign-in' : 'removed the ScaleMax key',
+    };
 }
 export async function verifyCodexConfiguration(ctx) {
     const configPath = codexConfigPath(ctx.home);
@@ -261,7 +435,7 @@ export async function configure(ctx) {
     }
     catch { }
     const nextAuth = codexAuth(ctx.apiKey, existingAuth);
-    const nextConfig = mergeCodexConfig(originalConfig, ctx.baseUrl, selectedModel(ctx), contentSha256(nextAuth));
+    const nextConfig = mergeCodexConfig(originalConfig, ctx.baseUrl, selectedModel(ctx), contentSha256(nextAuth), contentSha256(ctx.apiKey));
     const changed = originalConfig !== nextConfig || originalAuth !== nextAuth;
     const alreadyManaged = originalConfig.includes(GENERATED_HEADER);
     let verification;
@@ -312,24 +486,18 @@ export async function configure(ctx) {
 export async function remove(ctx) {
     const configPath = codexConfigPath(ctx.home);
     const authPath = codexAuthPath(ctx.home);
-    const [configText, authText] = await Promise.all([
-        fs.readFile(configPath, 'utf8').catch(() => ''),
-        fs.readFile(authPath, 'utf8').catch(() => ''),
-    ]);
-    const expectedAuthHash = managedAuthHash(configText);
-    // New generated configs bind ownership to the exact auth content. A hash
-    // mismatch means the user signed in or edited auth.json after setup, so
-    // removal must leave that current authentication state untouched. Legacy
-    // configs without the marker retain the conservative structural fallback.
-    const authManagedOverride = expectedAuthHash
-        ? contentSha256(authText) === expectedAuthHash
-        : configText.includes(GENERATED_HEADER)
-            ? undefined
-            : false;
+    // Read the ownership markers BEFORE config.toml is rewritten below.
+    const configText = await fs.readFile(configPath, 'utf8').catch(() => '');
+    const ownership = {
+        authHash: managedAuthHash(configText),
+        keyHash: markerHash(configText, managedKeyHashPrefix),
+        // Configs written before either marker existed: the original structural rule.
+        legacyStructural: configText.includes(GENERATED_HEADER),
+    };
     const snapshots = await captureFileSnapshots([configPath, authPath]);
     try {
-        const config = await restoreOrRemove(configPath, ctx);
-        const auth = await restoreOrRemove(authPath, ctx, authManagedOverride);
+        const config = await removeCodexConfig(configPath, ctx);
+        const auth = await removeCodexAuth(authPath, ctx, ownership);
         return {
             id,
             name,

package/dist/configure/models.js

@@ -15,9 +15,8 @@ const preferredOpenAi = [
     'gpt-5.6-sol',
     'gpt-6-sol',
     'gpt-6-luna',
-    'gpt-5.5',
-    'gpt-5.4',
-    'gpt-5.4-mini',
+    // gpt-5.5 / gpt-5.4 / gpt-5.4-mini retired 2026-09-30.
+    'gpt-5.6-luna',
     'gpt-5.3-codex',
     'codex-auto-review',
     // Gemini / Grok / Qwen ride the same OpenAI-compatible route, so they are
@@ -126,7 +125,8 @@ export function fastModel(ctx) {
 }
 export function fastOpenAiModel(ctx) {
     const ids = openAiModelIds(ctx);
-    return ids.find(id => id === 'gpt-5.4-mini')
+    return ids.find(id => id === 'gpt-5.6-luna')
+        || ids.find(id => id === 'gpt-6-luna')
         || ids.find(id => /(^|[-.])(mini|nano)([-.]|$)/i.test(id));
 }
 /** The lightweight model for an OpenAI-compatible chat client, if one exists. */

package/dist/configure/templates.js

@@ -11,7 +11,7 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
-    const models = ['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
+    const models = ['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.3-codex', 'codex-auto-review', 'deepseek-v4-flash'];
     return JSON.stringify({
         models: models.map(model => ({
             title: model === 'deepseek-v4-flash' ? 'ScaleMax DeepSeek V4 Flash' : `ScaleMax ${model}`,
@@ -21,7 +21,7 @@ export function continueConfig(apiKey, baseUrl) {
             apiKey,
             ...(model === 'deepseek-v4-flash' ? { useResponsesApi: false } : {})
         })),
-        tabAutocompleteModel: { title: 'ScaleMax gpt-5.4-mini', provider: 'openai', model: 'gpt-5.4-mini', apiBase: baseUrl, apiKey },
+        tabAutocompleteModel: { title: 'ScaleMax gpt-5.6-luna', provider: 'openai', model: 'gpt-5.6-luna', apiBase: baseUrl, apiKey },
         contextProviders: [{ name: 'code' }, { name: 'docs' }, { name: 'diff' }, { name: 'terminal' }]
     }, null, 2) + '\n';
 }

package/package.json

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