@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/utils/devtoolsService.js

@@ -0,0 +1,185 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+import WebSocket from 'ws';
+import { initActivityLogger, addNetworkTransport, ActivityLogger, } from './activityLogger.js';
+const DEFAULT_DEVTOOLS_PORT = 25417;
+const DEFAULT_DEVTOOLS_HOST = '127.0.0.1';
+const MAX_PROMOTION_ATTEMPTS = 3;
+let promotionAttempts = 0;
+let serverStartPromise = null;
+let connectedUrl = null;
+/**
+ * Probe whether a DevTools server is already listening on the given host:port.
+ * Returns true if a WebSocket handshake succeeds within a short timeout.
+ */
+function probeDevTools(host, port) {
+    return new Promise((resolve) => {
+        const ws = new WebSocket(`ws://${host}:${port}/ws`);
+        const timer = setTimeout(() => {
+            ws.close();
+            resolve(false);
+        }, 500);
+        ws.on('open', () => {
+            clearTimeout(timer);
+            ws.close();
+            resolve(true);
+        });
+        ws.on('error', () => {
+            clearTimeout(timer);
+            ws.close();
+            resolve(false);
+        });
+    });
+}
+/**
+ * Start a DevTools server, then check if we won the default port.
+ * If another instance grabbed it first (race), stop ours and connect as client.
+ * Returns { host, port } of the DevTools to connect to.
+ */
+async function startOrJoinDevTools(defaultHost, defaultPort) {
+    const mod = await import('@google/gemini-cli-devtools');
+    const devtools = mod.DevTools.getInstance();
+    const url = await devtools.start();
+    const actualPort = devtools.getPort();
+    if (actualPort === defaultPort) {
+        // We won the port — we are the server
+        debugLogger.log(`DevTools available at: ${url}`);
+        return { host: defaultHost, port: actualPort };
+    }
+    // Lost the race — someone else has the default port.
+    // Verify the winner is actually alive, then stop ours and connect to theirs.
+    const winnerAlive = await probeDevTools(defaultHost, defaultPort);
+    if (winnerAlive) {
+        await devtools.stop();
+        debugLogger.log(`DevTools (existing) at: http://${defaultHost}:${defaultPort}`);
+        return { host: defaultHost, port: defaultPort };
+    }
+    // Winner isn't responding (maybe also racing and failed) — keep ours
+    debugLogger.log(`DevTools available at: ${url}`);
+    return { host: defaultHost, port: actualPort };
+}
+/**
+ * Handle promotion: when reconnect fails, start or join a DevTools server
+ * and add a new network transport for the logger.
+ */
+async function handlePromotion(config) {
+    promotionAttempts++;
+    if (promotionAttempts > MAX_PROMOTION_ATTEMPTS) {
+        debugLogger.debug(`Giving up on DevTools promotion after ${MAX_PROMOTION_ATTEMPTS} attempts`);
+        return;
+    }
+    try {
+        const result = await startOrJoinDevTools(DEFAULT_DEVTOOLS_HOST, DEFAULT_DEVTOOLS_PORT);
+        addNetworkTransport(config, result.host, result.port, () => handlePromotion(config));
+    }
+    catch (err) {
+        debugLogger.debug('Failed to promote to DevTools server:', err);
+    }
+}
+/**
+ * Initializes the activity logger.
+ * Interception starts immediately in buffering mode.
+ * Transport is only attached when the user presses F12.
+ */
+export function setupInitialActivityLogger(config) {
+    const target = process.env['GEMINI_CLI_ACTIVITY_LOG_TARGET'];
+    if (target) {
+        if (!config.storage)
+            return;
+        initActivityLogger(config, { mode: 'file', filePath: target });
+    }
+    else {
+        // Start in buffering mode — transport attached later on F12
+        initActivityLogger(config, { mode: 'buffer' });
+    }
+}
+/**
+ * Starts the DevTools server and opens the UI in the browser.
+ * Returns the URL to the DevTools UI.
+ * Deduplicates concurrent calls — returns the same promise if already in flight.
+ */
+export function startDevToolsServer(config) {
+    if (connectedUrl)
+        return Promise.resolve(connectedUrl);
+    if (serverStartPromise)
+        return serverStartPromise;
+    serverStartPromise = startDevToolsServerImpl(config).catch((err) => {
+        serverStartPromise = null;
+        throw err;
+    });
+    return serverStartPromise;
+}
+async function startDevToolsServerImpl(config) {
+    const onReconnectFailed = () => handlePromotion(config);
+    // Probe for an existing DevTools server
+    const existing = await probeDevTools(DEFAULT_DEVTOOLS_HOST, DEFAULT_DEVTOOLS_PORT);
+    let host = DEFAULT_DEVTOOLS_HOST;
+    let port = DEFAULT_DEVTOOLS_PORT;
+    if (existing) {
+        debugLogger.log(`DevTools (existing) at: http://${DEFAULT_DEVTOOLS_HOST}:${DEFAULT_DEVTOOLS_PORT}`);
+    }
+    else {
+        // No existing server — start (or join if we lose the race)
+        try {
+            const result = await startOrJoinDevTools(DEFAULT_DEVTOOLS_HOST, DEFAULT_DEVTOOLS_PORT);
+            host = result.host;
+            port = result.port;
+        }
+        catch (err) {
+            debugLogger.debug('Failed to start DevTools:', err);
+            throw err;
+        }
+    }
+    // Promote the activity logger to use the network transport
+    addNetworkTransport(config, host, port, onReconnectFailed);
+    const capture = ActivityLogger.getInstance();
+    capture.enableNetworkLogging();
+    const url = `http://localhost:${port}`;
+    connectedUrl = url;
+    return url;
+}
+/**
+ * Handles the F12 key toggle for the DevTools panel.
+ * Starts the DevTools server, attempts to open the browser.
+ * If the panel is already open, it closes it.
+ * If the panel is closed:
+ * - Attempts to open the browser.
+ * - If browser opening is successful, the panel remains closed.
+ * - If browser opening fails or is not possible, the panel is opened.
+ */
+export async function toggleDevToolsPanel(config, isOpen, toggle, setOpen) {
+    if (isOpen) {
+        toggle();
+        return;
+    }
+    try {
+        const { openBrowserSecurely, shouldLaunchBrowser } = await import('@google/gemini-cli-core');
+        const url = await startDevToolsServer(config);
+        if (shouldLaunchBrowser()) {
+            try {
+                await openBrowserSecurely(url);
+                // Browser opened successfully, don't open drawer.
+                return;
+            }
+            catch (e) {
+                debugLogger.warn('Failed to open browser securely:', e);
+            }
+        }
+        // If we can't launch browser or it failed, open drawer.
+        setOpen();
+    }
+    catch (e) {
+        setOpen();
+        debugLogger.error('Failed to start DevTools server:', e);
+    }
+}
+/** Reset module-level state — test only. */
+export function resetForTesting() {
+    promotionAttempts = 0;
+    serverStartPromise = null;
+    connectedUrl = null;
+}

package/dist/utils/dialogScopeUtils.js

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isLoadableSettingScope, SettingScope, } from '../config/settings.js';
+import { isInSettingsScope } from './settingsUtils.js';
+/**
+ * Shared scope labels for dialog components that need to display setting scopes
+ */
+export const SCOPE_LABELS = {
+    [SettingScope.User]: 'User Settings',
+    [SettingScope.Workspace]: 'Workspace Settings',
+    [SettingScope.System]: 'System Settings',
+};
+/**
+ * Helper function to get scope items for radio button selects
+ */
+export function getScopeItems() {
+    return [
+        { label: SCOPE_LABELS[SettingScope.User], value: SettingScope.User },
+        {
+            label: SCOPE_LABELS[SettingScope.Workspace],
+            value: SettingScope.Workspace,
+        },
+        { label: SCOPE_LABELS[SettingScope.System], value: SettingScope.System },
+    ];
+}
+/**
+ * Generate scope message for a specific setting
+ */
+export function getScopeMessageForSetting(settingKey, selectedScope, settings) {
+    const otherScopes = Object.values(SettingScope)
+        .filter(isLoadableSettingScope)
+        .filter((scope) => scope !== selectedScope);
+    const modifiedInOtherScopes = otherScopes.filter((scope) => {
+        const scopeSettings = settings.forScope(scope).settings;
+        return isInSettingsScope(settingKey, scopeSettings);
+    });
+    if (modifiedInOtherScopes.length === 0) {
+        return '';
+    }
+    const modifiedScopesStr = modifiedInOtherScopes.join(', ');
+    const currentScopeSettings = settings.forScope(selectedScope).settings;
+    const existsInCurrentScope = isInSettingsScope(settingKey, currentScopeSettings);
+    return existsInCurrentScope
+        ? `(Also modified in ${modifiedScopesStr})`
+        : `(Modified in ${modifiedScopesStr})`;
+}

package/dist/utils/envVarResolver.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Resolves environment variables in a string.
+ * Replaces $VAR_NAME, ${VAR_NAME}, and ${VAR_NAME:-DEFAULT_VALUE} with their corresponding
+ * environment variable values. If the environment variable is not defined and no default
+ * value is provided, the original placeholder is preserved.
+ *
+ * @param value - The string that may contain environment variable placeholders
+ * @param customEnv - Optional record of environment variables to use before process.env
+ * @returns The string with environment variables resolved
+ *
+ * @example
+ * resolveEnvVarsInString("Token: $API_KEY") // Returns "Token: secret-123"
+ * resolveEnvVarsInString("URL: ${BASE_URL}/api") // Returns "URL: https://api.example.com/api"
+ * resolveEnvVarsInString("URL: ${MISSING_VAR:-https://default.com}") // Returns "URL: https://default.com"
+ * resolveEnvVarsInString("Missing: $UNDEFINED_VAR") // Returns "Missing: $UNDEFINED_VAR"
+ */
+export function resolveEnvVarsInString(value, customEnv) {
+    // Regex matches $VAR_NAME, ${VAR_NAME}, and ${VAR_NAME:-DEFAULT_VALUE}
+    const envVarRegex = /\$(?:(\w+)|{([^}]+?)(?::-([^}]*))?})/g;
+    return value.replace(envVarRegex, (match, varName1, varName2, defaultValue) => {
+        const varName = varName1 || varName2 || '';
+        if (!varName) {
+            return match;
+        }
+        if (customEnv && typeof customEnv[varName] === 'string') {
+            return customEnv[varName];
+        }
+        if (process && process.env) {
+            const val = process.env[varName];
+            if (typeof val === 'string') {
+                return val;
+            }
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        return match;
+    });
+}
+/**
+ * Recursively resolves environment variables in an object of any type.
+ * Handles strings, arrays, nested objects, and preserves other primitive types.
+ * Protected against circular references using a WeakSet to track visited objects.
+ *
+ * @param obj - The object to process for environment variable resolution
+ * @returns A new object with environment variables resolved
+ *
+ * @example
+ * const config = {
+ *   server: {
+ *     host: "$HOST",
+ *     port: "${PORT}",
+ *     enabled: true,
+ *     tags: ["$ENV", "api"]
+ *   }
+ * };
+ * const resolved = resolveEnvVarsInObject(config);
+ */
+export function resolveEnvVarsInObject(obj, customEnv) {
+    return resolveEnvVarsInObjectInternal(obj, new WeakSet(), customEnv);
+}
+/**
+ * Internal implementation of resolveEnvVarsInObject with circular reference protection.
+ *
+ * @param obj - The object to process
+ * @param visited - WeakSet to track visited objects and prevent circular references
+ * @returns A new object with environment variables resolved
+ */
+function resolveEnvVarsInObjectInternal(obj, visited, customEnv) {
+    if (obj === null ||
+        obj === undefined ||
+        typeof obj === 'boolean' ||
+        typeof obj === 'number') {
+        return obj;
+    }
+    if (typeof obj === 'string') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return resolveEnvVarsInString(obj, customEnv);
+    }
+    if (Array.isArray(obj)) {
+        // Check for circular reference
+        if (visited.has(obj)) {
+            // Return a shallow copy to break the cycle
+            const copy = [...obj];
+            const isTArray = (val) => Array.isArray(val);
+            if (isTArray(copy))
+                return copy;
+            throw new Error('Unreachable');
+        }
+        visited.add(obj);
+        const mapped = obj.map((item) => resolveEnvVarsInObjectInternal(item, visited, customEnv));
+        visited.delete(obj);
+        const isTArray = (val) => Array.isArray(val);
+        if (isTArray(mapped))
+            return mapped;
+        throw new Error('Unreachable');
+    }
+    if (typeof obj === 'object') {
+        // Check for circular reference
+        if (visited.has(obj)) {
+            // Return a shallow copy to break the cycle
+            return { ...obj };
+        }
+        visited.add(obj);
+        const newObj = { ...obj };
+        for (const key in newObj) {
+            if (Object.prototype.hasOwnProperty.call(newObj, key)) {
+                newObj[key] = resolveEnvVarsInObjectInternal(newObj[key], visited, customEnv);
+            }
+        }
+        visited.delete(obj);
+        return newObj;
+    }
+    return obj;
+}

package/dist/utils/errors.js

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OutputFormat, JsonFormatter, StreamJsonFormatter, JsonStreamEventType, uiTelemetryService, parseAndFormatApiError, FatalTurnLimitedError, FatalCancellationError, FatalToolExecutionError, isFatalToolError, debugLogger, coreEvents, getErrorType, getErrorMessage, } from '@google/gemini-cli-core';
+import { runSyncCleanup } from './cleanup.js';
+/**
+ * Extracts the appropriate error code from an error object.
+ */
+function extractErrorCode(error) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const errorWithCode = error;
+    // Prioritize exitCode for FatalError types, fall back to other codes
+    if (typeof errorWithCode.exitCode === 'number') {
+        return errorWithCode.exitCode;
+    }
+    if (errorWithCode.code !== undefined) {
+        return errorWithCode.code;
+    }
+    if (errorWithCode.status !== undefined) {
+        return errorWithCode.status;
+    }
+    return 1; // Default exit code
+}
+/**
+ * Converts an error code to a numeric exit code.
+ */
+function getNumericExitCode(errorCode) {
+    return typeof errorCode === 'number' ? errorCode : 1;
+}
+/**
+ * Handles errors consistently for both JSON and text output formats.
+ * In JSON mode, outputs formatted JSON error and exits.
+ * In streaming JSON mode, emits a result event with error status.
+ * In text mode, outputs error message and re-throws.
+ */
+export function handleError(error, config, customErrorCode) {
+    const errorMessage = parseAndFormatApiError(error, config.getContentGeneratorConfig()?.authType);
+    if (config.getOutputFormat() === OutputFormat.STREAM_JSON) {
+        const streamFormatter = new StreamJsonFormatter();
+        const errorCode = customErrorCode ?? extractErrorCode(error);
+        const metrics = uiTelemetryService.getMetrics();
+        streamFormatter.emitEvent({
+            type: JsonStreamEventType.RESULT,
+            timestamp: new Date().toISOString(),
+            status: 'error',
+            error: {
+                type: getErrorType(error),
+                message: errorMessage,
+            },
+            stats: streamFormatter.convertToStreamStats(metrics, 0),
+        });
+        runSyncCleanup();
+        process.exit(getNumericExitCode(errorCode));
+    }
+    else if (config.getOutputFormat() === OutputFormat.JSON) {
+        const formatter = new JsonFormatter();
+        const errorCode = customErrorCode ?? extractErrorCode(error);
+        const formattedError = formatter.formatError(error instanceof Error ? error : new Error(getErrorMessage(error)), errorCode, config.getSessionId());
+        coreEvents.emitFeedback('error', formattedError);
+        runSyncCleanup();
+        process.exit(getNumericExitCode(errorCode));
+    }
+    else {
+        throw error;
+    }
+}
+/**
+ * Handles tool execution errors specifically.
+ *
+ * Fatal errors (e.g., NO_SPACE_LEFT) cause the CLI to exit immediately,
+ * as they indicate unrecoverable system state.
+ *
+ * Non-fatal errors (e.g., INVALID_TOOL_PARAMS, FILE_NOT_FOUND, PATH_NOT_IN_WORKSPACE)
+ * are logged to stderr and the error response is sent back to the model,
+ * allowing it to self-correct.
+ */
+export function handleToolError(toolName, toolError, config, errorType, resultDisplay) {
+    const errorMessage = `Error executing tool ${toolName}: ${resultDisplay || toolError.message}`;
+    const isFatal = isFatalToolError(errorType);
+    if (isFatal) {
+        const toolExecutionError = new FatalToolExecutionError(errorMessage);
+        if (config.getOutputFormat() === OutputFormat.STREAM_JSON) {
+            const streamFormatter = new StreamJsonFormatter();
+            const metrics = uiTelemetryService.getMetrics();
+            streamFormatter.emitEvent({
+                type: JsonStreamEventType.RESULT,
+                timestamp: new Date().toISOString(),
+                status: 'error',
+                error: {
+                    type: errorType ?? 'FatalToolExecutionError',
+                    message: toolExecutionError.message,
+                },
+                stats: streamFormatter.convertToStreamStats(metrics, 0),
+            });
+        }
+        else if (config.getOutputFormat() === OutputFormat.JSON) {
+            const formatter = new JsonFormatter();
+            const formattedError = formatter.formatError(toolExecutionError, errorType ?? toolExecutionError.exitCode, config.getSessionId());
+            coreEvents.emitFeedback('error', formattedError);
+        }
+        else {
+            coreEvents.emitFeedback('error', errorMessage);
+        }
+        runSyncCleanup();
+        process.exit(toolExecutionError.exitCode);
+    }
+    // Non-fatal: log and continue
+    debugLogger.warn(errorMessage);
+}
+/**
+ * Handles cancellation/abort signals consistently.
+ */
+export function handleCancellationError(config) {
+    const cancellationError = new FatalCancellationError('Operation cancelled.');
+    if (config.getOutputFormat() === OutputFormat.STREAM_JSON) {
+        const streamFormatter = new StreamJsonFormatter();
+        const metrics = uiTelemetryService.getMetrics();
+        streamFormatter.emitEvent({
+            type: JsonStreamEventType.RESULT,
+            timestamp: new Date().toISOString(),
+            status: 'error',
+            error: {
+                type: getErrorType(cancellationError),
+                message: cancellationError.message,
+            },
+            stats: streamFormatter.convertToStreamStats(metrics, 0),
+        });
+        runSyncCleanup();
+        process.exit(cancellationError.exitCode);
+    }
+    else if (config.getOutputFormat() === OutputFormat.JSON) {
+        const formatter = new JsonFormatter();
+        const formattedError = formatter.formatError(cancellationError, cancellationError.exitCode, config.getSessionId());
+        coreEvents.emitFeedback('error', formattedError);
+        runSyncCleanup();
+        process.exit(cancellationError.exitCode);
+    }
+    else {
+        coreEvents.emitFeedback('error', cancellationError.message);
+        runSyncCleanup();
+        process.exit(cancellationError.exitCode);
+    }
+}
+/**
+ * Handles max session turns exceeded consistently.
+ */
+export function handleMaxTurnsExceededError(config) {
+    const maxTurnsError = new FatalTurnLimitedError('Reached max session turns for this session. Increase the number of turns by specifying maxSessionTurns in settings.json.');
+    if (config.getOutputFormat() === OutputFormat.STREAM_JSON) {
+        const streamFormatter = new StreamJsonFormatter();
+        const metrics = uiTelemetryService.getMetrics();
+        streamFormatter.emitEvent({
+            type: JsonStreamEventType.RESULT,
+            timestamp: new Date().toISOString(),
+            status: 'error',
+            error: {
+                type: getErrorType(maxTurnsError),
+                message: maxTurnsError.message,
+            },
+            stats: streamFormatter.convertToStreamStats(metrics, 0),
+        });
+        runSyncCleanup();
+        process.exit(maxTurnsError.exitCode);
+    }
+    else if (config.getOutputFormat() === OutputFormat.JSON) {
+        const formatter = new JsonFormatter();
+        const formattedError = formatter.formatError(maxTurnsError, maxTurnsError.exitCode, config.getSessionId());
+        coreEvents.emitFeedback('error', formattedError);
+        runSyncCleanup();
+        process.exit(maxTurnsError.exitCode);
+    }
+    else {
+        coreEvents.emitFeedback('error', maxTurnsError.message);
+        runSyncCleanup();
+        process.exit(maxTurnsError.exitCode);
+    }
+}

package/dist/utils/events.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EventEmitter } from 'node:events';
+export var TransientMessageType;
+(function (TransientMessageType) {
+    TransientMessageType["Warning"] = "warning";
+    TransientMessageType["Hint"] = "hint";
+})(TransientMessageType || (TransientMessageType = {}));
+export var AppEvent;
+(function (AppEvent) {
+    AppEvent["OpenDebugConsole"] = "open-debug-console";
+    AppEvent["Flicker"] = "flicker";
+    AppEvent["SelectionWarning"] = "selection-warning";
+    AppEvent["PasteTimeout"] = "paste-timeout";
+    AppEvent["TerminalBackground"] = "terminal-background";
+    AppEvent["TransientMessage"] = "transient-message";
+    AppEvent["ScrollToBottom"] = "scroll-to-bottom";
+})(AppEvent || (AppEvent = {}));
+export const appEvents = new EventEmitter();

package/dist/utils/featureToggleUtils.js

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SettingScope, isLoadableSettingScope, } from '../config/settings.js';
+/**
+ * Enables a feature by ensuring it is enabled in all writable scopes.
+ */
+export function enableFeature(settings, featureName, strategy) {
+    const writableScopes = [SettingScope.Workspace, SettingScope.User];
+    const foundInDisabledScopes = [];
+    const alreadyEnabledScopes = [];
+    for (const scope of writableScopes) {
+        if (isLoadableSettingScope(scope)) {
+            const scopePath = settings.forScope(scope).path;
+            if (strategy.needsEnabling(settings, scope, featureName)) {
+                foundInDisabledScopes.push({ scope, path: scopePath });
+            }
+            else {
+                alreadyEnabledScopes.push({ scope, path: scopePath });
+            }
+        }
+    }
+    if (foundInDisabledScopes.length === 0) {
+        return {
+            status: 'no-op',
+            featureName,
+            action: 'enable',
+            modifiedScopes: [],
+            alreadyInStateScopes: alreadyEnabledScopes,
+        };
+    }
+    const modifiedScopes = [];
+    for (const { scope, path } of foundInDisabledScopes) {
+        if (isLoadableSettingScope(scope)) {
+            strategy.enable(settings, scope, featureName);
+            modifiedScopes.push({ scope, path });
+        }
+    }
+    return {
+        status: 'success',
+        featureName,
+        action: 'enable',
+        modifiedScopes,
+        alreadyInStateScopes: alreadyEnabledScopes,
+    };
+}
+/**
+ * Disables a feature in the specified scope.
+ */
+export function disableFeature(settings, featureName, scope, strategy) {
+    if (!isLoadableSettingScope(scope)) {
+        return {
+            status: 'error',
+            featureName,
+            action: 'disable',
+            modifiedScopes: [],
+            alreadyInStateScopes: [],
+            error: `Invalid settings scope: ${scope}`,
+        };
+    }
+    const scopePath = settings.forScope(scope).path;
+    if (strategy.isExplicitlyDisabled(settings, scope, featureName)) {
+        return {
+            status: 'no-op',
+            featureName,
+            action: 'disable',
+            modifiedScopes: [],
+            alreadyInStateScopes: [{ scope, path: scopePath }],
+        };
+    }
+    // Check if it's already disabled in the other writable scope
+    const otherScope = scope === SettingScope.Workspace
+        ? SettingScope.User
+        : SettingScope.Workspace;
+    const alreadyDisabledInOther = [];
+    if (isLoadableSettingScope(otherScope)) {
+        if (strategy.isExplicitlyDisabled(settings, otherScope, featureName)) {
+            alreadyDisabledInOther.push({
+                scope: otherScope,
+                path: settings.forScope(otherScope).path,
+            });
+        }
+    }
+    strategy.disable(settings, scope, featureName);
+    return {
+        status: 'success',
+        featureName,
+        action: 'disable',
+        modifiedScopes: [{ scope, path: scopePath }],
+        alreadyInStateScopes: alreadyDisabledInOther,
+    };
+}