scalemax 0.1.50 → 0.1.52

package/dist/configure/hermes.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import { parseDocument } from 'yaml';
 import { atomicWrite, backupFile, captureFileSnapshots, restoreFileSnapshots, snapshotRollback } from '../utils/fs.js';
-import { clientConfigPath } from './paths.js';
+import { clientConfigPath, hermesHome } from './paths.js';
 import { isScaleMaxApiUrl, isScaleMaxManagedText } from './common.js';
 import { anthropicModelIds, anthropicOrigin, deepSeekChatModelIds, modelIdKey, modelSupportsTools, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredOpenAiResponsesModel } from './models.js';
 const id = 'hermes';
@@ -27,7 +27,7 @@ function exactChatLabel(ids) {
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
-function envPath(home) { return path.join(home, '.hermes', '.env'); }
+function envPath(ctx) { return path.join(hermesHome(ctx.home, ctx.platform, ctx.env), '.env'); }
 function managedEnv(text, apiKey) {
     const kept = text.split(/\r?\n/).filter(line => line.trim() !== envMarker && !line.startsWith(`${envKey}=`));
     while (kept.length && !kept[kept.length - 1])
@@ -73,8 +73,8 @@ async function removeLegacyArtifact(ctx) {
     return true;
 }
 export async function configure(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const secrets = envPath(ctx.home);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx);
     const legacy = path.join(ctx.home, '.hermes', 'config', 'scalemax.json');
     const snapshots = await captureFileSnapshots([file, secrets, legacy]);
     await fs.ensureDir(path.dirname(file), 0o700);
@@ -127,7 +127,12 @@ export async function configure(ctx) {
     doc.set('custom_providers', providers);
     const currentModel = asRecord(data.model);
     const currentProvider = String(currentModel.provider || '');
-    const activatesScaleMax = !currentProvider || currentProvider.startsWith('custom:scalemax');
+    // "auto" is Hermes's own unchosen default: the native Windows installer
+    // writes provider "auto" with an OpenRouter base_url into a fresh
+    // config.yaml, which left ScaleMax listed but never active ("No inference
+    // provider is configured yet"). A provider the user picked is left alone.
+    const unchosen = !currentProvider || currentProvider === 'auto';
+    const activatesScaleMax = unchosen || currentProvider.startsWith('custom:scalemax');
     if (activatesScaleMax) {
         const keepClaude = currentProvider === `custom:${claudeProviderName}` || claudeIds.includes(String(currentModel.default || ''));
         const keepDeepSeek = currentProvider === `custom:${deepSeekProviderName}`
@@ -142,7 +147,10 @@ export async function configure(ctx) {
         const activeModel = activeName === codexProviderName
             ? preferredOpenAiResponsesModel(ctx)
             : activeName === chatProviderName ? deepSeekIds[0] : preferredAnthropicModel(ctx);
-        doc.set('model', { ...currentModel, provider: `custom:${activeName}`, default: activeModel, max_tokens: 4096 });
+        // The custom provider carries its own base_url; a leftover model.base_url
+        // from the "auto" template would point Hermes back at OpenRouter.
+        const { base_url: _unchosenBaseUrl, ...keptModel } = currentModel;
+        doc.set('model', { ...(unchosen ? keptModel : currentModel), provider: `custom:${activeName}`, default: activeModel, max_tokens: 4096 });
     }
     const nextConfig = String(doc);
     const nextEnv = managedEnv(originalEnv, ctx.apiKey);
@@ -184,8 +192,8 @@ export async function configure(ctx) {
     };
 }
 export async function verify(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const secrets = envPath(ctx.home);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx);
     const doc = parseYaml(await fs.readFile(file, 'utf8'));
     const data = asRecord(doc.toJS());
     const providers = Array.isArray(data.custom_providers) ? data.custom_providers : [];
@@ -215,8 +223,8 @@ export async function verify(ctx) {
     return { id, name, changed: false, path: file, message: `verified ${codexIds.length} Codex/OpenAI, ${deepSeekIds.length} ${chatLabel}, and ${claudeIds.length} Claude models` };
 }
 export async function remove(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const secrets = envPath(ctx.home);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx);
     const currentEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
     if (!(await fs.pathExists(file))) {
         const removedLegacy = await removeLegacyArtifact(ctx);

package/dist/configure/models.js

@@ -14,6 +14,7 @@ const preferredClaude = [
     'claude-opus-4-7',
     'claude-opus-4-6',
     'claude-sonnet-4-5',
+    'claude-haiku-5-5',
     'claude-haiku-4-5-20251001'
 ];
 /** Codex runs only on these (plus Auto on an Auto key). */

package/dist/configure/paths.d.ts

@@ -2,5 +2,12 @@ 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;
+/**
+ * Hermes Agent's home: HERMES_HOME when set, else its platform default.
+ * Native Windows Hermes keeps config.yaml and .env in %LOCALAPPDATA%\\hermes
+ * and never reads ~/.hermes (hermes_constants._get_platform_default_hermes_home),
+ * so writing ~/.hermes there left Hermes with no ScaleMax provider.
+ */
+export declare function hermesHome(home: string, platform: NodeJS.Platform, env?: NodeJS.ProcessEnv): 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

@@ -3,6 +3,20 @@ 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'); }
+/**
+ * Hermes Agent's home: HERMES_HOME when set, else its platform default.
+ * Native Windows Hermes keeps config.yaml and .env in %LOCALAPPDATA%\\hermes
+ * and never reads ~/.hermes (hermes_constants._get_platform_default_hermes_home),
+ * so writing ~/.hermes there left Hermes with no ScaleMax provider.
+ */
+export function hermesHome(home, platform, env = process.env) {
+    const explicit = env.HERMES_HOME?.trim();
+    if (explicit)
+        return explicit;
+    if (platform === 'win32')
+        return path.join(env.LOCALAPPDATA?.trim() || path.join(home, 'AppData', 'Local'), 'hermes');
+    return path.join(home, '.hermes');
+}
 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');
@@ -23,7 +37,7 @@ export function clientConfigPath(id, home, platform, env = process.env) {
         case 'claude': return path.join(home, '.claude', 'settings.json');
         case 'opencode': return path.join(linux, 'opencode', 'opencode.json');
         case 'openclaw': return path.join(home, '.openclaw', 'openclaw.json');
-        case 'hermes': return path.join(home, '.hermes', 'config.yaml');
+        case 'hermes': return path.join(hermesHome(home, platform, env), 'config.yaml');
         case 'cherry-studio': return path.join(home, '.scalemax', 'cherry-studio.setup.json');
         case 'api-code': return path.join(home, '.scalemax', 'api-code.examples.json');
     }
@@ -41,7 +55,7 @@ export function installHints(id, home, platform, env = process.env) {
         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 'hermes': return [...new Set([hermesHome(home, platform, env), path.join(home, '.hermes')])];
         case 'cherry-studio': return [platform === 'darwin' ? '/Applications/Cherry Studio.app' : path.join(app, 'Cherry Studio'), path.join(linux, 'CherryStudio')];
         case 'api-code': return [path.join(home, '.scalemax')];
     }

package/dist/configure/roo-code.js

@@ -2,10 +2,10 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import JSON5 from 'json5';
 import { atomicWrite, backupFile, captureFileSnapshots, restoreFileSnapshots, snapshotRollback } from '../utils/fs.js';
-import { clientConfigPath } from './paths.js';
 import { anthropicModelIds, deepSeekChatModelIds, isDeepSeekChatModelId, modelIdKey, modelName, modelSupportsTools, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredChatCompletionsModel, preferredOpenAiResponsesModel } from './models.js';
 import { isAnthropicModel } from '../utils/api.js';
 import { rooRipgrepRepairNote } from '../repair/roo-ripgrep.js';
+import { rooSettingsTargets } from '../detect/roo-code.js';
 const id = 'roo-code';
 const name = 'Roo Code (VS Code)';
 const importSetting = 'roo-cline.autoImportSettingsPath';
@@ -167,23 +167,30 @@ export async function configure(ctx) {
     return note ? { ...result, note } : result;
 }
 async function configureHandoff(ctx) {
-    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const targets = await rooSettingsTargets(ctx.home, ctx.platform, ctx.env);
     const profileFile = importPath(ctx.home);
-    const snapshots = await captureFileSnapshots([settingsFile, profileFile]);
-    const originalSettings = await fs.readFile(settingsFile, 'utf8').catch(() => '');
+    const snapshots = await captureFileSnapshots([...targets.map(target => target.settingsFile), profileFile]);
     const originalProfile = await fs.readFile(profileFile, 'utf8').catch(() => '');
-    const settings = parseSettings(originalSettings, settingsFile);
-    const nextSettings = JSON.stringify({ ...settings, [importSetting]: importSettingValue }, null, 2) + '\n';
+    const writes = [];
+    for (const target of targets) {
+        const original = await fs.readFile(target.settingsFile, 'utf8').catch(() => '');
+        const next = JSON.stringify({ ...parseSettings(original, target.settingsFile), [importSetting]: importSettingValue }, null, 2) + '\n';
+        if (original !== next)
+            writes.push({ file: target.settingsFile, text: next });
+    }
     const nextProfile = handoff(ctx);
-    if (originalSettings === nextSettings && originalProfile === nextProfile) {
+    const editors = targets.map(target => target.editor).join(', ');
+    if (!writes.length && originalProfile === nextProfile) {
         await fs.chmod(profileFile, 0o600).catch(() => undefined);
-        return { id, name, changed: false, path: profileFile, message: 'supported Roo Code auto-import handoff is already current; reload VS Code to consume it', tip: ROO_CODE_MODE_TIP };
+        return { id, name, changed: false, path: profileFile, message: `supported Roo Code auto-import handoff is already current (${editors}); reload the editor to consume it`, tip: ROO_CODE_MODE_TIP };
     }
-    await backupFile(settingsFile, ctx.home);
+    for (const write of writes)
+        await backupFile(write.file, ctx.home);
     await backupFile(profileFile, ctx.home);
     try {
         await atomicWrite(profileFile, nextProfile, 0o600, ctx.platform);
-        await atomicWrite(settingsFile, nextSettings, 0o600, ctx.platform);
+        for (const write of writes)
+            await atomicWrite(write.file, write.text, 0o600, ctx.platform);
     }
     catch (error) {
         try {
@@ -199,19 +206,23 @@ async function configureHandoff(ctx) {
         name,
         changed: true,
         path: profileFile,
-        message: 'created a private, supported auto-import handoff; reload VS Code so Roo Code imports the profile into SecretStorage',
+        message: `created a private, supported auto-import handoff for ${editors}; reload the editor so Roo Code imports the profile into SecretStorage`,
         tip: ROO_CODE_MODE_TIP,
         rollback: snapshotRollback(snapshots, ctx.platform),
     };
 }
 export async function verify(ctx) {
-    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     const profileFile = importPath(ctx.home);
-    const settings = parseSettings(await fs.readFile(settingsFile, 'utf8'), settingsFile);
+    let handoffSet = true;
+    for (const target of await rooSettingsTargets(ctx.home, ctx.platform, ctx.env)) {
+        const settings = parseSettings(await fs.readFile(target.settingsFile, 'utf8'), target.settingsFile);
+        if (settings[importSetting] !== importSettingValue)
+            handoffSet = false;
+    }
     const profile = await fs.readJson(profileFile).catch(() => undefined);
     const expectedProfiles = profilesFor(ctx);
     const current = currentProfileFor(ctx, expectedProfiles);
-    if (settings[importSetting] !== importSettingValue || profile?.providerProfiles?.currentApiConfigName !== current.name) {
+    if (!handoffSet || profile?.providerProfiles?.currentApiConfigName !== current.name) {
         throw new Error('Roo Code auto-import handoff is incomplete.');
     }
     if (profile?.globalSettings?.maxWorkspaceFiles !== 0) {
@@ -232,10 +243,11 @@ export async function verify(ctx) {
     return { id, name, changed: false, path: profileFile, message: 'verified supported auto-import handoff (runtime activation requires a VS Code reload)' };
 }
 export async function remove(ctx) {
-    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     const profileFile = importPath(ctx.home);
     let changed = false;
-    if (await fs.pathExists(settingsFile)) {
+    for (const { settingsFile } of await rooSettingsTargets(ctx.home, ctx.platform, ctx.env)) {
+        if (!(await fs.pathExists(settingsFile)))
+            continue;
         const text = await fs.readFile(settingsFile, 'utf8');
         const settings = parseSettings(text, settingsFile);
         if (settings[importSetting] === importSettingValue) {

package/dist/detect/roo-code.d.ts

@@ -5,6 +5,13 @@ export interface EditorExtensionRoot {
     editor: string;
     /** Path segments below the home folder. */
     segments: readonly string[];
+    /**
+     * The editor's user-data folder name under the platform config root
+     * (%APPDATA% / ~/Library/Application Support / ~/.config), whose
+     * `User/settings.json` Roo Code reads. Absent for remote servers, which have
+     * no local settings file of their own.
+     */
+    userDir?: string;
 }
 /**
  * VS Code's own per-user extension folders. Detection stays limited to these
@@ -17,6 +24,18 @@ export declare const VSCODE_EXTENSION_ROOTS: readonly EditorExtensionRoot[];
  * installed extension itself rather than writing editor settings.
  */
 export declare const ALL_EDITOR_EXTENSION_ROOTS: readonly EditorExtensionRoot[];
+export interface RooSettingsTarget {
+    editor: string;
+    /** That editor's user settings.json, which holds roo-cline.autoImportSettingsPath. */
+    settingsFile: string;
+}
+/**
+ * Every settings.json Roo Code reads its auto-import path from: VS Code's
+ * (always, as before) plus each VS Code-family editor that has Roo Code
+ * installed. A fork reads only its own settings.json, so writing VS Code's
+ * alone left Roo in Antigravity, Cursor or Windsurf unconfigured.
+ */
+export declare function rooSettingsTargets(home: string, platform: NodeJS.Platform, env?: NodeJS.ProcessEnv): Promise<RooSettingsTarget[]>;
 export interface RooExtensionDir {
     editor: string;
     /** Absolute extension folder, e.g. ~/.vscode/extensions/rooveterinaryinc.roo-cline-3.54.0 */

package/dist/detect/roo-code.js

@@ -3,14 +3,15 @@ import fs from 'fs-extra';
 import JSON5 from 'json5';
 import { commandExists } from '../utils/exec.js';
 import { clientConfigPath } from '../configure/paths.js';
+import { configRoot } from '../utils/paths.js';
 export const ROO_EXTENSION_PATTERN = /^rooveterinaryinc\.roo-cline-/i;
 /**
  * VS Code's own per-user extension folders. Detection stays limited to these
  * because configure writes VS Code's settings.json, which forks do not read.
  */
 export const VSCODE_EXTENSION_ROOTS = [
-    { editor: 'VS Code', segments: ['.vscode', 'extensions'] },
-    { editor: 'VS Code Insiders', segments: ['.vscode-insiders', 'extensions'] },
+    { editor: 'VS Code', segments: ['.vscode', 'extensions'], userDir: 'Code' },
+    { editor: 'VS Code Insiders', segments: ['.vscode-insiders', 'extensions'], userDir: 'Code - Insiders' },
 ];
 /**
  * Every per-user extension folder Roo Code can be installed into: VS Code,
@@ -19,14 +20,36 @@ export const VSCODE_EXTENSION_ROOTS = [
  */
 export const ALL_EDITOR_EXTENSION_ROOTS = [
     ...VSCODE_EXTENSION_ROOTS,
-    { editor: 'Cursor', segments: ['.cursor', 'extensions'] },
-    { editor: 'Windsurf', segments: ['.windsurf', 'extensions'] },
-    { editor: 'VSCodium', segments: ['.vscode-oss', 'extensions'] },
+    { editor: 'Cursor', segments: ['.cursor', 'extensions'], userDir: 'Cursor' },
+    { editor: 'Windsurf', segments: ['.windsurf', 'extensions'], userDir: 'Windsurf' },
+    { editor: 'VSCodium', segments: ['.vscode-oss', 'extensions'], userDir: 'VSCodium' },
     { editor: 'VS Code Server', segments: ['.vscode-server', 'extensions'] },
     { editor: 'Cursor Server', segments: ['.cursor-server', 'extensions'] },
-    { editor: 'Trae', segments: ['.trae', 'extensions'] },
-    { editor: 'Kiro', segments: ['.kiro', 'extensions'] },
+    { editor: 'Trae', segments: ['.trae', 'extensions'], userDir: 'Trae' },
+    { editor: 'Kiro', segments: ['.kiro', 'extensions'], userDir: 'Kiro' },
+    // Google Antigravity (VS Code fork, Open VSX). Product.json on Windows,
+    // 2.5.5: dataFolderName ".antigravity-ide", user data "%APPDATA%\Antigravity IDE".
+    { editor: 'Antigravity IDE', segments: ['.antigravity-ide', 'extensions'], userDir: 'Antigravity IDE' },
+    { editor: 'Antigravity', segments: ['.antigravity', 'extensions'], userDir: 'Antigravity' },
 ];
+/**
+ * Every settings.json Roo Code reads its auto-import path from: VS Code's
+ * (always, as before) plus each VS Code-family editor that has Roo Code
+ * installed. A fork reads only its own settings.json, so writing VS Code's
+ * alone left Roo in Antigravity, Cursor or Windsurf unconfigured.
+ */
+export async function rooSettingsTargets(home, platform, env = process.env) {
+    const targets = [{ editor: 'VS Code', settingsFile: clientConfigPath('roo-code', home, platform, env) }];
+    const root = configRoot(home, platform, env);
+    const forks = ALL_EDITOR_EXTENSION_ROOTS.filter(entry => entry.userDir && entry.editor !== 'VS Code');
+    for (const hit of await findRooExtensionDirs(home, forks)) {
+        const fork = forks.find(entry => entry.editor === hit.editor);
+        const settingsFile = path.join(root, fork.userDir, 'User', 'settings.json');
+        if (!targets.some(target => target.settingsFile === settingsFile))
+            targets.push({ editor: hit.editor, settingsFile });
+    }
+    return targets;
+}
 /** Roo Code extension folders under the given roots; missing roots are skipped. */
 export async function findRooExtensionDirs(home, roots = VSCODE_EXTENSION_ROOTS) {
     const hits = [];
@@ -42,7 +65,7 @@ export async function findRooExtensionDirs(home, roots = VSCODE_EXTENSION_ROOTS)
     return hits;
 }
 export async function detect(ctx) {
-    const paths = (await findRooExtensionDirs(ctx.home)).map(hit => hit.dir);
+    const paths = (await findRooExtensionDirs(ctx.home, ALL_EDITOR_EXTENSION_ROOTS.filter(entry => entry.userDir))).map(hit => hit.dir);
     const executable = await commandExists('code', ctx.env);
     if (executable)
         paths.unshift('command:code');

package/package.json

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