@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadMcp.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { mapFindFirst } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
-import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { RunOnceScheduler, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -26,10 +26,23 @@ import { ExtensionHostKind, extensionHostKindToString } from '@codingame/monaco-
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 let MainThreadMcp = class MainThreadMcp extends Disposable {
-    constructor(_extHostContext, _mcpRegistry, dialogService, _authenticationService, authenticationMcpServersService, authenticationMCPServerAccessService, authenticationMCPServerUsageService, _dynamicAuthenticationProviderStorageService, _extensionService, _contextKeyService, _telemetryService) {
+    constructor(
+        _extHostContext,
+        _mcpRegistry,
+        dialogService,
+        _authenticationService,
+        authenticationMcpServersService,
+        authenticationMCPServerAccessService,
+        authenticationMCPServerUsageService,
+        _dynamicAuthenticationProviderStorageService,
+        _extensionService,
+        _contextKeyService,
+        _telemetryService
+    ) {
         super();
         this._extHostContext = _extHostContext;
         this._mcpRegistry = _mcpRegistry;
@@ -47,7 +60,9 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         this._serverDefinitions = ( new Map());
         this._serverAuthTracking = ( new McpServerAuthTracker());
         this._collectionDefinitions = this._register(( new DisposableMap()));
-        this._register(_authenticationService.onDidChangeSessions(e => this._onDidChangeAuthSessions(e.providerId, e.label)));
+        this._register(
+            _authenticationService.onDidChangeSessions(e => this._onDidChangeAuthSessions(e.providerId, e.label))
+        );
         const proxy = this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostMcp));
         this._register(this._mcpRegistry.registerDelegate({
             priority: _extHostContext.extensionHostKind === ExtensionHostKind.LocalWebWorker ? 0 : 1,
@@ -64,7 +79,10 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
                 return true;
             },
             async substituteVariables(serverDefinition, launch) {
-                const ser = await proxy.$substituteVariables(serverDefinition.variableReplacement?.folder?.uri, McpServerLaunch.toSerialized(launch));
+                const ser = await proxy.$substituteVariables(
+                    serverDefinition.variableReplacement?.folder?.uri,
+                    McpServerLaunch.toSerialized(launch)
+                );
                 return McpServerLaunch.fromSerialized(ser);
             },
             start: (_collection, serverDefiniton, resolveLaunch, options) => {
@@ -79,20 +97,41 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
                 proxy.$startMcp(id, {
                     launch: resolveLaunch,
                     defaultCwd: serverDefiniton.variableReplacement?.folder?.uri,
-                    errorOnUserInteraction: options?.errorOnUserInteraction,
+                    errorOnUserInteraction: options?.errorOnUserInteraction
                 });
                 return launch;
-            },
+            }
+        }));
+        const onDidChangeMcpServerDefinitionsTrigger = this._register(( new RunOnceScheduler(() => this._publishServerDefinitions(), 500)));
+        this._register(autorun(reader => {
+            const collections = this._mcpRegistry.collections.read(reader);
+            for (const collection of collections) {
+                collection.serverDefinitions.read(reader);
+            }
+            if (!onDidChangeMcpServerDefinitionsTrigger.isScheduled()) {
+                onDidChangeMcpServerDefinitionsTrigger.schedule();
+            }
         }));
+        onDidChangeMcpServerDefinitionsTrigger.schedule();
+    }
+    _publishServerDefinitions() {
+        const collections = this._mcpRegistry.collections.get();
+        const allServers = [];
+        for (const collection of collections) {
+            const servers = collection.serverDefinitions.get();
+            for (const server of servers) {
+                allServers.push(McpServerDefinition.toSerialized(server));
+            }
+        }
+        this._proxy.$onDidChangeMcpServerDefinitions(allServers);
     }
     $upsertMcpCollection(collection, serversDto) {
         const servers = ( serversDto.map(McpServerDefinition.fromSerialized));
         const existing = this._collectionDefinitions.get(collection.id);
         if (existing) {
             existing.servers.set(servers, undefined);
-        }
-        else {
-            const serverDefinitions = observableValue('mcpServers', servers);
+        } else {
+            const serverDefinitions = observableValue("mcpServers", servers);
             const extensionId = ( new ExtensionIdentifier(collection.extensionId));
             const store = ( new DisposableStore());
             const handle = store.add(( new MutableDisposable()));
@@ -100,28 +139,27 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
                 handle.value ??= this._mcpRegistry.registerCollection({
                     ...collection,
                     source: extensionId,
-                    resolveServerLanch: collection.canResolveLaunch ? (async (def) => {
+                    resolveServerLanch: collection.canResolveLaunch ? (async def => {
                         const r = await this._proxy.$resolveMcpLaunch(collection.id, def.label);
                         return r ? McpServerLaunch.fromSerialized(r) : undefined;
                     }) : undefined,
                     trustBehavior: collection.isTrustedByDefault ? McpServerTrust.Kind.Trusted : McpServerTrust.Kind.TrustedOnNonce,
                     remoteAuthority: this._extHostContext.remoteAuthority,
-                    serverDefinitions,
+                    serverDefinitions
                 });
             };
-            const whenClauseStr = mapFindFirst(this._extensionService.extensions, e => ExtensionIdentifier.equals(extensionId, e.identifier)
-                ? e.contributes?.mcpServerDefinitionProviders?.find(p => extensionPrefixedIdentifier(extensionId, p.id) === collection.id)?.when
-                : undefined);
+            const whenClauseStr = mapFindFirst(
+                this._extensionService.extensions,
+                e => ExtensionIdentifier.equals(extensionId, e.identifier) ? e.contributes?.mcpServerDefinitionProviders?.find(p => extensionPrefixedIdentifier(extensionId, p.id) === collection.id)?.when : undefined
+            );
             const whenClause = whenClauseStr && ContextKeyExpr.deserialize(whenClauseStr);
             if (!whenClause) {
                 register();
-            }
-            else {
+            } else {
                 const evaluate = () => {
                     if (this._contextKeyService.contextMatchesRules(whenClause)) {
                         register();
-                    }
-                    else {
+                    } else {
                         handle.clear();
                     }
                 };
@@ -130,7 +168,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             }
             this._collectionDefinitions.set(collection.id, {
                 servers: serverDefinitions,
-                dispose: () => store.dispose(),
+                dispose: () => store.dispose()
             });
         }
     }
@@ -151,7 +189,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         }
     }
     $onDidPublishLog(id, level, log) {
-        if (typeof level === 'string') {
+        if (typeof level === "string") {
             level = LogLevel.Info;
             log = level;
         }
@@ -167,7 +205,14 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         }
         return this._getSessionForProvider(id, server, providerId, scopes, undefined, options.errorOnUserInteraction);
     }
-    async $getTokenFromServerMetadata(id, authDetails, { errorOnUserInteraction, forceNewRegistration } = {}) {
+    async $getTokenFromServerMetadata(
+        id,
+        authDetails,
+        {
+            errorOnUserInteraction,
+            forceNewRegistration
+        } = {}
+    ) {
         const server = this._serverDefinitions.get(id);
         if (!server) {
             return undefined;
@@ -178,23 +223,43 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         let providerId = await this._authenticationService.getOrActivateProviderIdForServer(authorizationServer, resourceServer);
         if (forceNewRegistration && providerId) {
             if (!this._authenticationService.isDynamicAuthenticationProvider(providerId)) {
-                throw ( new Error('Cannot force new registration for a non-dynamic authentication provider.'));
+                throw ( new Error("Cannot force new registration for a non-dynamic authentication provider."));
             }
             this._authenticationService.unregisterAuthenticationProvider(providerId);
             await this._dynamicAuthenticationProviderStorageService.removeDynamicProvider(providerId);
             providerId = undefined;
         }
         if (!providerId) {
-            const provider = await this._authenticationService.createDynamicAuthenticationProvider(authorizationServer, authDetails.authorizationServerMetadata, authDetails.resourceMetadata);
+            const provider = await this._authenticationService.createDynamicAuthenticationProvider(
+                authorizationServer,
+                authDetails.authorizationServerMetadata,
+                authDetails.resourceMetadata
+            );
             if (!provider) {
                 return undefined;
             }
             providerId = provider.id;
         }
-        return this._getSessionForProvider(id, server, providerId, resolvedScopes, authorizationServer, errorOnUserInteraction);
+        return this._getSessionForProvider(
+            id,
+            server,
+            providerId,
+            resolvedScopes,
+            authorizationServer,
+            errorOnUserInteraction
+        );
     }
-    async _getSessionForProvider(serverId, server, providerId, scopes, authorizationServer, errorOnUserInteraction = false) {
-        const sessions = await this._authenticationService.getSessions(providerId, scopes, { authorizationServer }, true);
+    async _getSessionForProvider(
+        serverId,
+        server,
+        providerId,
+        scopes,
+        authorizationServer,
+        errorOnUserInteraction = false
+    ) {
+        const sessions = await this._authenticationService.getSessions(providerId, scopes, {
+            authorizationServer
+        }, true);
         const accountNamePreference = this.authenticationMcpServersService.getAccountPreference(server.id, providerId);
         let matchingAccountPreferenceSession;
         if (accountNamePreference) {
@@ -204,7 +269,13 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         let session;
         if (sessions.length) {
             if (matchingAccountPreferenceSession && this.authenticationMCPServerAccessService.isAccessAllowed(providerId, matchingAccountPreferenceSession.account.label, server.id)) {
-                this.authenticationMCPServerUsageService.addAccountUsage(providerId, matchingAccountPreferenceSession.account.label, scopes, server.id, server.label);
+                this.authenticationMCPServerUsageService.addAccountUsage(
+                    providerId,
+                    matchingAccountPreferenceSession.account.label,
+                    scopes,
+                    server.id,
+                    server.label
+                );
                 this._serverAuthTracking.track(providerId, serverId, scopes);
                 return matchingAccountPreferenceSession.accessToken;
             }
@@ -215,23 +286,20 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             }
         }
         if (errorOnUserInteraction) {
-            throw ( new UserInteractionRequiredError('authentication'));
+            throw ( new UserInteractionRequiredError("authentication"));
         }
         const isAllowed = await this.loginPrompt(server.label, provider.label, false);
         if (!isAllowed) {
-            throw ( new Error('User did not consent to login.'));
+            throw ( new Error("User did not consent to login."));
         }
         if (sessions.length) {
             if (provider.supportsMultipleAccounts && errorOnUserInteraction) {
-                throw ( new UserInteractionRequiredError('authentication'));
+                throw ( new UserInteractionRequiredError("authentication"));
             }
-            session = provider.supportsMultipleAccounts
-                ? await this.authenticationMcpServersService.selectSession(providerId, server.id, server.label, scopes, sessions)
-                : sessions[0];
-        }
-        else {
+            session = provider.supportsMultipleAccounts ? await this.authenticationMcpServersService.selectSession(providerId, server.id, server.label, scopes, sessions) : sessions[0];
+        } else {
             if (errorOnUserInteraction) {
-                throw ( new UserInteractionRequiredError('authentication'));
+                throw ( new UserInteractionRequiredError("authentication"));
             }
             const accountToCreate = matchingAccountPreferenceSession?.account;
             do {
@@ -240,11 +308,13 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
                     account: accountToCreate,
                     authorizationServer
                 });
-            } while (accountToCreate
-                && accountToCreate.label !== session.account.label
-                && !(await this.continueWithIncorrectAccountPrompt(session.account.label, accountToCreate.label)));
+            } while (accountToCreate && accountToCreate.label !== session.account.label && !(await this.continueWithIncorrectAccountPrompt(session.account.label, accountToCreate.label)));
         }
-        this.authenticationMCPServerAccessService.updateAllowedMcpServers(providerId, session.account.label, [{ id: server.id, name: server.label, allowed: true }]);
+        this.authenticationMCPServerAccessService.updateAllowedMcpServers(providerId, session.account.label, [{
+            id: server.id,
+            name: server.label,
+            allowed: true
+        }]);
         this.authenticationMcpServersService.updateAccountPreference(server.id, providerId, session.account);
         this.authenticationMCPServerUsageService.addAccountUsage(providerId, session.account.label, scopes, server.id, server.label);
         this._serverAuthTracking.track(providerId, serverId, scopes);
@@ -252,25 +322,22 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
     }
     async continueWithIncorrectAccountPrompt(chosenAccountLabel, requestedAccountLabel) {
         const result = await this.dialogService.prompt({
-            message: ( localize(2535, "Incorrect account detected")),
+            message: ( localize(2538, "Incorrect account detected")),
             detail: ( localize(
-                2536,
+                2539,
                 "The chosen account, {0}, does not match the requested account, {1}.",
                 chosenAccountLabel,
                 requestedAccountLabel
             )),
             type: Severity.Warning,
             cancelButton: true,
-            buttons: [
-                {
-                    label: ( localize(2537, 'Keep {0}', chosenAccountLabel)),
-                    run: () => chosenAccountLabel
-                },
-                {
-                    label: ( localize(2538, 'Login with {0}', requestedAccountLabel)),
-                    run: () => requestedAccountLabel
-                }
-            ],
+            buttons: [{
+                label: ( localize(2540, "Keep {0}", chosenAccountLabel)),
+                run: () => chosenAccountLabel
+            }, {
+                label: ( localize(2541, "Login with {0}", requestedAccountLabel)),
+                run: () => requestedAccountLabel
+            }]
         });
         if (!result.result) {
             throw ( new CancellationError());
@@ -282,7 +349,10 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         if (!serversUsingProvider) {
             return;
         }
-        for (const { serverId, scopes } of serversUsingProvider) {
+        for (const {
+            serverId,
+            scopes
+        } of serversUsingProvider) {
             const server = this._servers.get(serverId);
             const serverDefinition = this._serverDefinitions.get(serverId);
             if (!server || !serverDefinition) {
@@ -294,11 +364,10 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             }
             try {
                 await this._getSessionForProvider(serverId, serverDefinition, providerId, scopes, undefined, true);
-            }
-            catch (e) {
+            } catch (e) {
                 if (UserInteractionRequiredError.is(e)) {
                     server.pushLog(LogLevel.Warning, ( localize(
-                        2539,
+                        2542,
                         "Authentication session for {0} removed, stopping server",
                         providerLabel
                     )));
@@ -308,35 +377,33 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         }
     }
     $logMcpAuthSetup(data) {
-        this._telemetryService.publicLog2('mcp/authSetup', data);
+        this._telemetryService.publicLog2("mcp/authSetup", data);
     }
     async loginPrompt(mcpLabel, providerLabel, recreatingSession) {
-        const message = recreatingSession
-            ? ( localize(
-            2540,
+        const message = recreatingSession ? ( localize(
+            2543,
             "The MCP Server Definition '{0}' wants you to authenticate to {1}.",
             mcpLabel,
             providerLabel
-        ))
-            : ( localize(
-            2541,
+        )) : ( localize(
+            2544,
             "The MCP Server Definition '{0}' wants to authenticate to {1}.",
             mcpLabel,
             providerLabel
         ));
-        const buttons = [
-            {
-                label: ( localize(2542, "&&Allow")),
-                run() {
-                    return true;
-                },
+        const buttons = [{
+            label: ( localize(2545, "&&Allow")),
+            run() {
+                return true;
             }
-        ];
-        const { result } = await this.dialogService.prompt({
+        }];
+        const {
+            result
+        } = await this.dialogService.prompt({
             type: Severity.Info,
             message,
             buttons,
-            cancelButton: true,
+            cancelButton: true
         });
         return result ?? false;
     }
@@ -350,36 +417,25 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         super.dispose();
     }
 };
-MainThreadMcp = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadMcp),
-    ( __param(1, IMcpRegistry)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IAuthenticationService)),
-    ( __param(4, IAuthenticationMcpService)),
-    ( __param(5, IAuthenticationMcpAccessService)),
-    ( __param(6, IAuthenticationMcpUsageService)),
-    ( __param(7, IDynamicAuthenticationProviderStorageService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, ITelemetryService))
-], MainThreadMcp);
+MainThreadMcp = __decorate([extHostNamedCustomer(MainContext.MainThreadMcp), ( __param(1, IMcpRegistry)), ( __param(2, IDialogService)), ( __param(3, IAuthenticationService)), ( __param(4, IAuthenticationMcpService)), ( __param(5, IAuthenticationMcpAccessService)), ( __param(6, IAuthenticationMcpUsageService)), ( __param(7, IDynamicAuthenticationProviderStorageService)), ( __param(8, IExtensionService)), ( __param(9, IContextKeyService)), ( __param(10, ITelemetryService))], MainThreadMcp);
 class ExtHostMcpServerLaunch extends Disposable {
     pushLog(level, message) {
-        this._onDidLog.fire({ message, level });
+        this._onDidLog.fire({
+            message,
+            level
+        });
     }
     pushMessage(message) {
         let parsed;
         try {
             parsed = JSON.parse(message);
-        }
-        catch (e) {
+        } catch (e) {
             this.pushLog(LogLevel.Warning, `Failed to parse message: ${JSON.stringify(message)}`);
         }
         if (parsed) {
             if (Array.isArray(parsed)) {
                 parsed.forEach(p => this._onDidReceiveMessage.fire(p));
-            }
-            else {
+            } else {
                 this._onDidReceiveMessage.fire(parsed);
             }
         }
@@ -388,19 +444,26 @@ class ExtHostMcpServerLaunch extends Disposable {
         super();
         this.stop = stop;
         this.send = send;
-        this.state = observableValue('mcpServerState', { state: McpConnectionState.Kind.Starting });
+        this.state = observableValue("mcpServerState", {
+            state: McpConnectionState.Kind.Starting
+        });
         this._onDidLog = this._register(( new Emitter()));
         this.onDidLog = this._onDidLog.event;
         this._onDidReceiveMessage = this._register(( new Emitter()));
         this.onDidReceiveMessage = this._onDidReceiveMessage.event;
         this._register(disposableTimeout(() => {
-            this.pushLog(LogLevel.Info, `Starting server from ${extensionHostKindToString(extHostKind)} extension host`);
+            this.pushLog(
+                LogLevel.Info,
+                `Starting server from ${extensionHostKindToString(extHostKind)} extension host`
+            );
         }));
     }
     extHostDispose() {
         if (McpConnectionState.isRunning(this.state.get())) {
-            this.pushLog(LogLevel.Warning, 'Extension host shut down, server will stop.');
-            this.state.set({ state: McpConnectionState.Kind.Stopped }, undefined);
+            this.pushLog(LogLevel.Warning, "Extension host shut down, server will stop.");
+            this.state.set({
+                state: McpConnectionState.Kind.Stopped
+            }, undefined);
         }
         this.dispose();
     }
@@ -418,7 +481,10 @@ class McpServerAuthTracker {
     track(providerId, serverId, scopes) {
         const servers = this._tracking.get(providerId) || [];
         const filtered = servers.filter(s => s.serverId !== serverId);
-        filtered.push({ serverId, scopes });
+        filtered.push({
+            serverId,
+            scopes
+        });
         this._tracking.set(providerId, filtered);
     }
     untrack(serverId) {
@@ -426,8 +492,7 @@ class McpServerAuthTracker {
             const filtered = servers.filter(s => s.serverId !== serverId);
             if (filtered.length === 0) {
                 this._tracking.delete(providerId);
-            }
-            else {
+            } else {
                 this._tracking.set(providerId, filtered);
             }
         }

package/vscode/src/vs/workbench/api/browser/mainThreadMessageService.js

@@ -13,12 +13,19 @@ import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 
 var MainThreadMessageService_1;
 let MainThreadMessageService = class MainThreadMessageService {
-    static { MainThreadMessageService_1 = this; }
-    static { this.URGENT_NOTIFICATION_SOURCES = [
-        'vscode.github-authentication',
-        'vscode.microsoft-authentication'
-    ]; }
-    constructor(extHostContext, _notificationService, _commandService, _dialogService, extensionService) {
+    static {
+        MainThreadMessageService_1 = this;
+    }
+    static {
+        this.URGENT_NOTIFICATION_SOURCES = ["vscode.github-authentication", "vscode.microsoft-authentication"];
+    }
+    constructor(
+        extHostContext,
+        _notificationService,
+        _commandService,
+        _dialogService,
+        extensionService
+    ) {
         this._notificationService = _notificationService;
         this._commandService = _commandService;
         this._dialogService = _dialogService;
@@ -34,8 +41,7 @@ let MainThreadMessageService = class MainThreadMessageService {
     $showMessage(severity, message, options, commands) {
         if (options.modal) {
             return this._showModalMessage(severity, message, options.detail, commands, options.useCustom);
-        }
-        else {
+        } else {
             return this._showMessage(severity, message, commands, options);
         }
     }
@@ -60,22 +66,25 @@ let MainThreadMessageService = class MainThreadMessageService {
                 sourceIsUrgent = MainThreadMessageService_1.URGENT_NOTIFICATION_SOURCES.includes(source.id);
             }
             if (!source) {
-                source = ( localize(2543, "Extension"));
+                source = ( localize(2546, "Extension"));
             }
             const secondaryActions = [];
             if (options.source) {
                 secondaryActions.push(toAction({
                     id: options.source.identifier.value,
-                    label: ( localize(2544, "Manage Extension")),
+                    label: ( localize(2547, "Manage Extension")),
                     run: () => {
-                        return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                        return this._commandService.executeCommand("_extensions.manage", options.source.identifier.value);
                     }
                 }));
             }
             const messageHandle = this._notificationService.notify({
                 severity,
                 message,
-                actions: { primary: primaryActions, secondary: secondaryActions },
+                actions: {
+                    primary: primaryActions,
+                    secondary: secondaryActions
+                },
                 source,
                 priority: sourceIsUrgent ? NotificationPriority.URGENT : NotificationPriority.DEFAULT,
                 sticky: sourceIsUrgent
@@ -95,26 +104,26 @@ let MainThreadMessageService = class MainThreadMessageService {
             };
             if (command.isCloseAffordance) {
                 cancelButton = button;
-            }
-            else {
+            } else {
                 buttons.push(button);
             }
         }
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localize(2545, "Cancel")),
+                    label: ( localize(2548, "Cancel")),
                     run: () => undefined
                 };
-            }
-            else {
+            } else {
                 cancelButton = {
-                    label: ( localize(2546, "&&OK")),
+                    label: ( localize(2549, "&&OK")),
                     run: () => undefined
                 };
             }
         }
-        const { result } = await this._dialogService.prompt({
+        const {
+            result
+        } = await this._dialogService.prompt({
             type: severity,
             message,
             detail,
@@ -125,12 +134,9 @@ let MainThreadMessageService = class MainThreadMessageService {
         return result;
     }
 };
-MainThreadMessageService = MainThreadMessageService_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadMessageService),
-    ( __param(1, INotificationService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, IDialogService)),
-    ( __param(4, IExtensionService))
-], MainThreadMessageService);
+MainThreadMessageService = MainThreadMessageService_1 = __decorate(
+    [extHostNamedCustomer(MainContext.MainThreadMessageService), ( __param(1, INotificationService)), ( __param(2, ICommandService)), ( __param(3, IDialogService)), ( __param(4, IExtensionService))],
+    MainThreadMessageService
+);
 
 export { MainThreadMessageService };