scalemax 0.1.51 → 0.1.52

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.51",
+  "version": "0.1.52",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {