@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalProfileResolverService.js

@@ -0,0 +1,417 @@
+import { __decorate } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { NeverShowAgainScope } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { isUriComponents, terminalProfileArgsMatch } from '../../../../platform/terminal/common/terminalProfiles.js';
+const generatedProfileName = 'Generated';
+let migrationMessageShown = false;
+class BaseTerminalProfileResolverService {
+    get defaultProfileName() { return this._defaultProfileName; }
+    constructor(_context, _configurationService, _configurationResolverService, _historyService, _logService, _terminalProfileService, _workspaceContextService, _remoteAgentService, _storageService, _notificationService) {
+        this._context = _context;
+        this._configurationService = _configurationService;
+        this._configurationResolverService = _configurationResolverService;
+        this._historyService = _historyService;
+        this._logService = _logService;
+        this._terminalProfileService = _terminalProfileService;
+        this._workspaceContextService = _workspaceContextService;
+        this._remoteAgentService = _remoteAgentService;
+        this._storageService = _storageService;
+        this._notificationService = _notificationService;
+        this._iconRegistry = getIconRegistry();
+        if (this._remoteAgentService.getConnection()) {
+            this._remoteAgentService.getEnvironment().then(env => this._primaryBackendOs = env?.os || OS);
+        }
+        else {
+            this._primaryBackendOs = OS;
+        }
+        this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.defaultProfile.windows" ) ||
+                e.affectsConfiguration("terminal.integrated.defaultProfile.osx" ) ||
+                e.affectsConfiguration("terminal.integrated.defaultProfile.linux" )) {
+                this._refreshDefaultProfileName();
+            }
+        });
+        this._terminalProfileService.onDidChangeAvailableProfiles(() => this._refreshDefaultProfileName());
+        this.showProfileMigrationNotification();
+    }
+    async _refreshDefaultProfileName() {
+        if (this._primaryBackendOs) {
+            this._defaultProfileName = (await this.getDefaultProfile({
+                remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority,
+                os: this._primaryBackendOs
+            }))?.profileName;
+        }
+    }
+    resolveIcon(shellLaunchConfig, os) {
+        if (shellLaunchConfig.icon) {
+            shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon) || this.getDefaultIcon();
+            return;
+        }
+        if (shellLaunchConfig.customPtyImplementation) {
+            shellLaunchConfig.icon = this.getDefaultIcon();
+            return;
+        }
+        if (shellLaunchConfig.executable) {
+            return;
+        }
+        const defaultProfile = this._getUnresolvedRealDefaultProfile(os);
+        if (defaultProfile) {
+            shellLaunchConfig.icon = defaultProfile.icon;
+        }
+        if (!shellLaunchConfig.icon) {
+            shellLaunchConfig.icon = this.getDefaultIcon();
+        }
+    }
+    getDefaultIcon(resource) {
+        return this._iconRegistry.getIcon(this._configurationService.getValue("terminal.integrated.tabs.defaultIcon" , { resource })) || Codicon.terminal;
+    }
+    async resolveShellLaunchConfig(shellLaunchConfig, options) {
+        let resolvedProfile;
+        if (shellLaunchConfig.executable) {
+            resolvedProfile = await this._resolveProfile({
+                path: shellLaunchConfig.executable,
+                args: shellLaunchConfig.args,
+                profileName: generatedProfileName,
+                isDefault: false
+            }, options);
+        }
+        else {
+            resolvedProfile = await this.getDefaultProfile(options);
+        }
+        shellLaunchConfig.executable = resolvedProfile.path;
+        shellLaunchConfig.args = resolvedProfile.args;
+        if (resolvedProfile.env) {
+            if (shellLaunchConfig.env) {
+                shellLaunchConfig.env = { ...shellLaunchConfig.env, ...resolvedProfile.env };
+            }
+            else {
+                shellLaunchConfig.env = resolvedProfile.env;
+            }
+        }
+        const resource = shellLaunchConfig === undefined || typeof shellLaunchConfig.cwd === 'string' ? undefined : shellLaunchConfig.cwd;
+        shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon)
+            || this._getCustomIcon(resolvedProfile.icon)
+            || this.getDefaultIcon(resource);
+        if (resolvedProfile.overrideName) {
+            shellLaunchConfig.name = resolvedProfile.profileName;
+        }
+        shellLaunchConfig.color = shellLaunchConfig.color
+            || resolvedProfile.color
+            || this._configurationService.getValue("terminal.integrated.tabs.defaultColor" , { resource });
+        if (shellLaunchConfig.useShellEnvironment === undefined) {
+            shellLaunchConfig.useShellEnvironment = this._configurationService.getValue("terminal.integrated.inheritEnv" );
+        }
+    }
+    async getDefaultShell(options) {
+        return (await this.getDefaultProfile(options)).path;
+    }
+    async getDefaultShellArgs(options) {
+        return (await this.getDefaultProfile(options)).args || [];
+    }
+    async getDefaultProfile(options) {
+        return this._resolveProfile(await this._getUnresolvedDefaultProfile(options), options);
+    }
+    getEnvironment(remoteAuthority) {
+        return this._context.getEnvironment(remoteAuthority);
+    }
+    _getCustomIcon(icon) {
+        if (!icon) {
+            return undefined;
+        }
+        if (typeof icon === 'string') {
+            return ThemeIcon.fromId(icon);
+        }
+        if (ThemeIcon.isThemeIcon(icon)) {
+            return icon;
+        }
+        if (URI.isUri(icon) || isUriComponents(icon)) {
+            return URI.revive(icon);
+        }
+        if (typeof icon === 'object' && 'light' in icon && 'dark' in icon) {
+            const castedIcon = icon;
+            if ((URI.isUri(castedIcon.light) || isUriComponents(castedIcon.light)) && (URI.isUri(castedIcon.dark) || isUriComponents(castedIcon.dark))) {
+                return { light: URI.revive(castedIcon.light), dark: URI.revive(castedIcon.dark) };
+            }
+        }
+        return undefined;
+    }
+    async _getUnresolvedDefaultProfile(options) {
+        if (options.allowAutomationShell) {
+            const automationShellProfile = this._getUnresolvedAutomationShellProfile(options);
+            if (automationShellProfile) {
+                return automationShellProfile;
+            }
+        }
+        const shellSettingProfile = await this._getUnresolvedShellSettingDefaultProfile(options);
+        if (shellSettingProfile) {
+            return this._setIconForAutomation(options, shellSettingProfile);
+        }
+        await this._terminalProfileService.profilesReady;
+        const defaultProfile = this._getUnresolvedRealDefaultProfile(options.os);
+        if (defaultProfile) {
+            return this._setIconForAutomation(options, defaultProfile);
+        }
+        return this._setIconForAutomation(options, await this._getUnresolvedFallbackDefaultProfile(options));
+    }
+    _setIconForAutomation(options, profile) {
+        if (options.allowAutomationShell) {
+            const profileClone = deepClone(profile);
+            profileClone.icon = Codicon.tools;
+            return profileClone;
+        }
+        return profile;
+    }
+    _getUnresolvedRealDefaultProfile(os) {
+        return this._terminalProfileService.getDefaultProfile(os);
+    }
+    async _getUnresolvedShellSettingDefaultProfile(options) {
+        let executable = this._configurationService.getValue(`${"terminal.integrated.shell." }${this._getOsKey(options.os)}`);
+        if (!this._isValidShell(executable)) {
+            const shellArgs = this._configurationService.inspect(`${"terminal.integrated.shellArgs." }${this._getOsKey(options.os)}`);
+            if (!shellArgs.userValue && !shellArgs.workspaceValue) {
+                return undefined;
+            }
+        }
+        if (!executable || !this._isValidShell(executable)) {
+            executable = await this._context.getDefaultSystemShell(options.remoteAuthority, options.os);
+        }
+        let args;
+        const shellArgsSetting = this._configurationService.getValue(`${"terminal.integrated.shellArgs." }${this._getOsKey(options.os)}`);
+        if (this._isValidShellArgs(shellArgsSetting, options.os)) {
+            args = shellArgsSetting;
+        }
+        if (args === undefined) {
+            if (options.os === 2  && args === undefined && path.parse(executable).name.match(/(zsh|bash|fish)/)) {
+                args = ['--login'];
+            }
+            else {
+                args = [];
+            }
+        }
+        const icon = this._guessProfileIcon(executable);
+        return {
+            profileName: generatedProfileName,
+            path: executable,
+            args,
+            icon,
+            isDefault: false
+        };
+    }
+    async _getUnresolvedFallbackDefaultProfile(options) {
+        const executable = await this._context.getDefaultSystemShell(options.remoteAuthority, options.os);
+        if (options.os === OS) {
+            let existingProfile = this._terminalProfileService.availableProfiles.find(e => path.parse(e.path).name === path.parse(executable).name);
+            if (existingProfile) {
+                if (options.allowAutomationShell) {
+                    existingProfile = deepClone(existingProfile);
+                    existingProfile.icon = Codicon.tools;
+                }
+                return existingProfile;
+            }
+        }
+        let args;
+        if (options.os === 2  && path.parse(executable).name.match(/(zsh|bash)/)) {
+            args = ['--login'];
+        }
+        else {
+            args = [];
+        }
+        const icon = this._guessProfileIcon(executable);
+        return {
+            profileName: generatedProfileName,
+            path: executable,
+            args,
+            icon,
+            isDefault: false
+        };
+    }
+    _getUnresolvedAutomationShellProfile(options) {
+        const automationShell = this._configurationService.getValue(`terminal.integrated.automationShell.${this._getOsKey(options.os)}`);
+        if (automationShell && typeof automationShell === 'string') {
+            return {
+                path: automationShell,
+                profileName: generatedProfileName,
+                isDefault: false,
+                icon: Codicon.tools
+            };
+        }
+        const automationProfile = this._configurationService.getValue(`terminal.integrated.automationProfile.${this._getOsKey(options.os)}`);
+        if (this._isValidAutomationProfile(automationProfile, options.os)) {
+            automationProfile.icon = this._getCustomIcon(automationProfile.icon) || Codicon.tools;
+            return automationProfile;
+        }
+        return undefined;
+    }
+    async _resolveProfile(profile, options) {
+        if (options.os === 1 ) {
+            const env = await this._context.getEnvironment(options.remoteAuthority);
+            const isWoW64 = !!env.hasOwnProperty('PROCESSOR_ARCHITEW6432');
+            const windir = env.windir;
+            if (!isWoW64 && windir) {
+                const sysnativePath = path.join(windir, 'Sysnative').replace(/\//g, '\\').toLowerCase();
+                if (profile.path && profile.path.toLowerCase().indexOf(sysnativePath) === 0) {
+                    profile.path = path.join(windir, 'System32', profile.path.substr(sysnativePath.length + 1));
+                }
+            }
+            if (profile.path) {
+                profile.path = profile.path.replace(/\//g, '\\');
+            }
+        }
+        const env = await this._context.getEnvironment(options.remoteAuthority);
+        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(options.remoteAuthority ? Schemas.vscodeRemote : Schemas.file);
+        const lastActiveWorkspace = activeWorkspaceRootUri ? withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined;
+        profile.path = await this._resolveVariables(profile.path, env, lastActiveWorkspace);
+        if (profile.args) {
+            if (typeof profile.args === 'string') {
+                profile.args = await this._resolveVariables(profile.args, env, lastActiveWorkspace);
+            }
+            else {
+                profile.args = await Promise.all(( profile.args.map(arg => this._resolveVariables(arg, env, lastActiveWorkspace))));
+            }
+        }
+        return profile;
+    }
+    async _resolveVariables(value, env, lastActiveWorkspace) {
+        try {
+            value = await this._configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, value);
+        }
+        catch (e) {
+            this._logService.error(`Could not resolve shell`, e);
+        }
+        return value;
+    }
+    _getOsKey(os) {
+        switch (os) {
+            case 3 : return 'linux';
+            case 2 : return 'osx';
+            case 1 : return 'windows';
+        }
+    }
+    _guessProfileIcon(shell) {
+        const file = path.parse(shell).name;
+        switch (file) {
+            case 'bash':
+                return Codicon.terminalBash;
+            case 'pwsh':
+            case 'powershell':
+                return Codicon.terminalPowershell;
+            case 'tmux':
+                return Codicon.terminalTmux;
+            case 'cmd':
+                return Codicon.terminalCmd;
+            default:
+                return undefined;
+        }
+    }
+    _isValidShell(shell) {
+        if (!shell) {
+            return false;
+        }
+        return typeof shell === 'string';
+    }
+    _isValidShellArgs(shellArgs, os) {
+        if (shellArgs === undefined) {
+            return true;
+        }
+        if (os === 1  && typeof shellArgs === 'string') {
+            return true;
+        }
+        if (Array.isArray(shellArgs) && shellArgs.every(e => typeof e === 'string')) {
+            return true;
+        }
+        return false;
+    }
+    async createProfileFromShellAndShellArgs(shell, shellArgs) {
+        const detectedProfile = this._terminalProfileService.availableProfiles?.find(p => {
+            if (p.path !== shell) {
+                return false;
+            }
+            if (p.args === undefined || typeof p.args === 'string') {
+                return p.args === shellArgs;
+            }
+            return p.path === shell && equals(p.args, (shellArgs || []));
+        });
+        const fallbackProfile = (await this.getDefaultProfile({
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority,
+            os: this._primaryBackendOs
+        }));
+        fallbackProfile.profileName = `${fallbackProfile.path} (migrated)`;
+        const profile = detectedProfile || fallbackProfile;
+        const args = this._isValidShellArgs(shellArgs, this._primaryBackendOs) ? shellArgs : profile.args;
+        const createdProfile = {
+            profileName: profile.profileName,
+            path: profile.path,
+            args,
+            isDefault: true
+        };
+        if (detectedProfile && detectedProfile.profileName === createdProfile.profileName && detectedProfile.path === createdProfile.path && terminalProfileArgsMatch(detectedProfile.args, createdProfile.args)) {
+            return detectedProfile.profileName;
+        }
+        return createdProfile;
+    }
+    _isValidAutomationProfile(profile, os) {
+        if (profile === null || profile === undefined || typeof profile !== 'object') {
+            return false;
+        }
+        if ('path' in profile && typeof profile.path === 'string') {
+            return true;
+        }
+        return false;
+    }
+    async showProfileMigrationNotification() {
+        const shouldMigrateToProfile = (!!this._configurationService.getValue("terminal.integrated.shell."  + this._primaryBackendOs) ||
+            !!this._configurationService.inspect("terminal.integrated.shellArgs."  + this._primaryBackendOs).userValue) &&
+            !!this._configurationService.getValue("terminal.integrated.defaultProfile."  + this._primaryBackendOs);
+        if (shouldMigrateToProfile && this._storageService.getBoolean("terminals.integrated.profile-migration" , 1 , true) && !migrationMessageShown) {
+            this._notificationService.prompt(Severity.Info, ( localize(
+                'terminalProfileMigration',
+                "The terminal is using deprecated shell/shellArgs settings, do you want to migrate it to a profile?"
+            )), [
+                {
+                    label: ( localize('migrateToProfile', "Migrate")),
+                    run: async () => {
+                        const shell = this._configurationService.getValue("terminal.integrated.shell."  + this._primaryBackendOs);
+                        const shellArgs = this._configurationService.getValue("terminal.integrated.shellArgs."  + this._primaryBackendOs);
+                        const profile = await this.createProfileFromShellAndShellArgs(shell, shellArgs);
+                        if (typeof profile === 'string') {
+                            await this._configurationService.updateValue("terminal.integrated.defaultProfile."  + this._primaryBackendOs, profile);
+                            this._logService.trace(`migrated from shell/shellArgs, using existing profile ${profile}`);
+                        }
+                        else {
+                            const profiles = { ...this._configurationService.inspect("terminal.integrated.profiles."  + this._primaryBackendOs).userValue };
+                            const profileConfig = { path: profile.path };
+                            if (profile.args) {
+                                profileConfig.args = profile.args;
+                            }
+                            profiles[profile.profileName] = profileConfig;
+                            await this._configurationService.updateValue("terminal.integrated.profiles."  + this._primaryBackendOs, profiles);
+                            await this._configurationService.updateValue("terminal.integrated.defaultProfile."  + this._primaryBackendOs, profile.profileName);
+                            this._logService.trace(`migrated from shell/shellArgs, ${shell} ${shellArgs} to profile ${JSON.stringify(profile)}`);
+                        }
+                        await this._configurationService.updateValue("terminal.integrated.shell."  + this._primaryBackendOs, undefined);
+                        await this._configurationService.updateValue("terminal.integrated.shellArgs."  + this._primaryBackendOs, undefined);
+                    }
+                },
+            ], {
+                neverShowAgain: { id: "terminals.integrated.profile-migration" , scope: NeverShowAgainScope.WORKSPACE }
+            });
+            migrationMessageShown = true;
+        }
+    }
+}
+BaseTerminalProfileResolverService.__decorator = ( __decorate([
+    debounce(200)
+], BaseTerminalProfileResolverService.prototype, "_refreshDefaultProfileName", null));
+export { BaseTerminalProfileResolverService };

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalProfileService.js

@@ -0,0 +1,213 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { AutoOpenBarrier } from 'monaco-editor/esm/vs/base/common/async.js';
+import { throttle } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isWeb, OS, isWindows, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerTerminalDefaultProfileConfiguration } from '../../../../platform/terminal/common/terminalPlatformConfiguration.js';
+import { terminalProfileArgsMatch, terminalIconsEqual } from '../../../../platform/terminal/common/terminalProfiles.js';
+import { ITerminalInstanceService } from './terminal.js';
+import { refreshTerminalActions } from './terminalActions.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { ITerminalContributionService } from '../common/terminalExtensionPoints.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+let TerminalProfileService = class TerminalProfileService {
+    get onDidChangeAvailableProfiles() { return this._onDidChangeAvailableProfiles.event; }
+    get profilesReady() { return this._profilesReadyBarrier.wait().then(() => { }); }
+    get availableProfiles() {
+        if (!this._platformConfigJustRefreshed) {
+            this.refreshAvailableProfiles();
+        }
+        return this._availableProfiles || [];
+    }
+    get contributedProfiles() {
+        return this._contributedProfiles || [];
+    }
+    constructor(_contextKeyService, _configurationService, _terminalContributionService, _extensionService, _remoteAgentService, _environmentService, _terminalInstanceService) {
+        this._contextKeyService = _contextKeyService;
+        this._configurationService = _configurationService;
+        this._terminalContributionService = _terminalContributionService;
+        this._extensionService = _extensionService;
+        this._remoteAgentService = _remoteAgentService;
+        this._environmentService = _environmentService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._contributedProfiles = [];
+        this._platformConfigJustRefreshed = false;
+        this._profileProviders = ( new Map());
+        this._onDidChangeAvailableProfiles = ( new Emitter());
+        this._extensionService.onDidChangeExtensions(() => this.refreshAvailableProfiles());
+        this._webExtensionContributedProfileContextKey = TerminalContextKeys.webExtensionContributedProfile.bindTo(this._contextKeyService);
+        this._updateWebContextKey();
+        this._profilesReadyBarrier = ( new AutoOpenBarrier(20000));
+        this.refreshAvailableProfiles();
+        this._setupConfigListener();
+    }
+    async _setupConfigListener() {
+        const platformKey = await this.getPlatformKey();
+        this._configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration("terminal.integrated.defaultProfile."  + platformKey) ||
+                e.affectsConfiguration("terminal.integrated.profiles."  + platformKey) ||
+                e.affectsConfiguration("terminal.integrated.useWslProfiles" )) {
+                if (e.source !== 7 ) {
+                    this.refreshAvailableProfiles();
+                    this._platformConfigJustRefreshed = false;
+                }
+                else {
+                    this._platformConfigJustRefreshed = true;
+                }
+            }
+        });
+    }
+    getDefaultProfileName() {
+        return this._defaultProfileName;
+    }
+    getDefaultProfile(os) {
+        let defaultProfileName;
+        if (os) {
+            defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${this._getOsKey(os)}`);
+            if (!defaultProfileName || typeof defaultProfileName !== 'string') {
+                return undefined;
+            }
+        }
+        else {
+            defaultProfileName = this._defaultProfileName;
+        }
+        if (!defaultProfileName) {
+            return undefined;
+        }
+        return this.availableProfiles.find(e => e.profileName === defaultProfileName && !e.isAutoDetected);
+    }
+    _getOsKey(os) {
+        switch (os) {
+            case 3 : return 'linux';
+            case 2 : return 'osx';
+            case 1 : return 'windows';
+        }
+    }
+    refreshAvailableProfiles() {
+        this._refreshAvailableProfilesNow();
+    }
+    async _refreshAvailableProfilesNow() {
+        const profiles = await this._detectProfiles(true);
+        const profilesChanged = !(equals(profiles, this._availableProfiles, profilesEqual));
+        const contributedProfilesChanged = await this._updateContributedProfiles();
+        if (profilesChanged || contributedProfilesChanged) {
+            this._availableProfiles = profiles;
+            this._onDidChangeAvailableProfiles.fire(this._availableProfiles);
+            this._profilesReadyBarrier.open();
+            this._updateWebContextKey();
+            await this._refreshPlatformConfig(this._availableProfiles);
+        }
+    }
+    async _updateContributedProfiles() {
+        const platformKey = await this.getPlatformKey();
+        const excludedContributedProfiles = [];
+        const configProfiles = this._configurationService.getValue("terminal.integrated.profiles."  + platformKey);
+        for (const [profileName, value] of Object.entries(configProfiles)) {
+            if (value === null) {
+                excludedContributedProfiles.push(profileName);
+            }
+        }
+        const filteredContributedProfiles = Array.from(this._terminalContributionService.terminalProfiles.filter(p => !excludedContributedProfiles.includes(p.title)));
+        const contributedProfilesChanged = !equals(filteredContributedProfiles, this._contributedProfiles, contributedProfilesEqual);
+        this._contributedProfiles = filteredContributedProfiles;
+        return contributedProfilesChanged;
+    }
+    getContributedProfileProvider(extensionIdentifier, id) {
+        const extMap = this._profileProviders.get(extensionIdentifier);
+        return extMap?.get(id);
+    }
+    async _detectProfiles(includeDetectedProfiles) {
+        const primaryBackend = await this._terminalInstanceService.getBackend(this._environmentService.remoteAuthority);
+        if (!primaryBackend) {
+            return this._availableProfiles || [];
+        }
+        const platform = await this.getPlatformKey();
+        this._defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${platform}`) ?? undefined;
+        return primaryBackend.getProfiles(this._configurationService.getValue(`${"terminal.integrated.profiles." }${platform}`), this._defaultProfileName, includeDetectedProfiles);
+    }
+    _updateWebContextKey() {
+        this._webExtensionContributedProfileContextKey.set(isWeb && this._contributedProfiles.length > 0);
+    }
+    async _refreshPlatformConfig(profiles) {
+        const env = await this._remoteAgentService.getEnvironment();
+        registerTerminalDefaultProfileConfiguration({ os: env?.os || OS, profiles }, this._contributedProfiles);
+        refreshTerminalActions(profiles);
+    }
+    async getPlatformKey() {
+        const env = await this._remoteAgentService.getEnvironment();
+        if (env) {
+            return env.os === 1  ? 'windows' : (env.os === 2  ? 'osx' : 'linux');
+        }
+        return isWindows ? 'windows' : (isMacintosh ? 'osx' : 'linux');
+    }
+    registerTerminalProfileProvider(extensionIdentifier, id, profileProvider) {
+        let extMap = this._profileProviders.get(extensionIdentifier);
+        if (!extMap) {
+            extMap = ( new Map());
+            this._profileProviders.set(extensionIdentifier, extMap);
+        }
+        extMap.set(id, profileProvider);
+        return toDisposable(() => this._profileProviders.delete(id));
+    }
+    async registerContributedProfile(args) {
+        const platformKey = await this.getPlatformKey();
+        const profilesConfig = await this._configurationService.getValue(`${"terminal.integrated.profiles." }${platformKey}`);
+        if (typeof profilesConfig === 'object') {
+            const newProfile = {
+                extensionIdentifier: args.extensionIdentifier,
+                icon: args.options.icon,
+                id: args.id,
+                title: args.title,
+                color: args.options.color
+            };
+            profilesConfig[args.title] = newProfile;
+        }
+        await this._configurationService.updateValue(`${"terminal.integrated.profiles." }${platformKey}`, profilesConfig, 2 );
+        return;
+    }
+    async getContributedDefaultProfile(shellLaunchConfig) {
+        if (shellLaunchConfig && !shellLaunchConfig.extHostTerminalId && !('executable' in shellLaunchConfig)) {
+            const key = await this.getPlatformKey();
+            const defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${key}`);
+            const contributedDefaultProfile = this.contributedProfiles.find(p => p.title === defaultProfileName);
+            return contributedDefaultProfile;
+        }
+        return undefined;
+    }
+};
+TerminalProfileService.__decorator = ( __decorate([
+    throttle(2000)
+], TerminalProfileService.prototype, "refreshAvailableProfiles", null));
+TerminalProfileService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ITerminalContributionService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IRemoteAgentService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, ITerminalInstanceService))
+], TerminalProfileService));
+function profilesEqual(one, other) {
+    return one.profileName === other.profileName &&
+        terminalProfileArgsMatch(one.args, other.args) &&
+        one.color === other.color &&
+        terminalIconsEqual(one.icon, other.icon) &&
+        one.isAutoDetected === other.isAutoDetected &&
+        one.isDefault === other.isDefault &&
+        one.overrideName === other.overrideName &&
+        one.path === other.path;
+}
+function contributedProfilesEqual(one, other) {
+    return one.extensionIdentifier === other.extensionIdentifier &&
+        one.color === other.color &&
+        one.icon === other.icon &&
+        one.id === other.id &&
+        one.title === other.title;
+}
+export { TerminalProfileService };