@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/api/common/extHostAuthentication.js

@@ -26,9 +26,17 @@ import { observableValue } from '../../../base/common/observableInternal/observa
 import { derivedOpts } from '../../../base/common/observableInternal/observables/derived.js';
 import { autorun } from '../../../base/common/observableInternal/reactions/autorun.js';
 
-const IExtHostAuthentication = ( createDecorator('IExtHostAuthentication'));
+const IExtHostAuthentication = ( createDecorator("IExtHostAuthentication"));
 let ExtHostAuthentication = class ExtHostAuthentication {
-    constructor(extHostRpc, _initData, _extHostWindow, _extHostUrls, _extHostProgress, _extHostLoggerService, _logService) {
+    constructor(
+        extHostRpc,
+        _initData,
+        _extHostWindow,
+        _extHostUrls,
+        _extHostProgress,
+        _extHostLoggerService,
+        _logService
+    ) {
         this._initData = _initData;
         this._extHostWindow = _extHostWindow;
         this._extHostUrls = _extHostUrls;
@@ -45,42 +53,39 @@ let ExtHostAuthentication = class ExtHostAuthentication {
     }
     getExtensionScopedSessionsEvent(extensionId) {
         const normalizedExtensionId = extensionId.toLowerCase();
-        return Event.chain(this._onDidChangeSessions.event, ($) => ( $
-            .filter(e => !e.extensionIdFilter || e.extensionIdFilter.includes(normalizedExtensionId))
-            .map(e => ({ provider: e.provider }))));
+        return Event.chain(this._onDidChangeSessions.event, $ => ( $.filter(
+            e => !e.extensionIdFilter || e.extensionIdFilter.includes(normalizedExtensionId)
+        ).map(e => ({
+            provider: e.provider
+        }))));
     }
     async getSession(requestingExtension, providerId, scopesOrRequest, options = {}) {
         const extensionId = ExtensionIdentifier.toKey(requestingExtension.identifier);
         const keys = ( Object.keys(options));
-        const optionsStr = ( keys
-            .map(key => {
+        const optionsStr = ( keys.map(key => {
             switch (key) {
-                case 'account':
-                    return `${key}:${options.account?.id}`;
-                case 'createIfNone':
-                case 'forceNewSession': {
-                    const value = typeof options[key] === 'boolean'
-                        ? `${options[key]}`
-                        : `'${options[key]?.detail}/${options[key]?.learnMore?.toString()}'`;
+            case "account":
+                return `${key}:${options.account?.id}`;
+            case "createIfNone":
+            case "forceNewSession":
+                {
+                    const value = typeof options[key] === "boolean" ? `${options[key]}` : `'${options[key]?.detail}/${options[key]?.learnMore?.toString()}'`;
                     return `${key}:${value}`;
                 }
-                case 'authorizationServer':
-                    return `${key}:${options.authorizationServer?.toString(true)}`;
-                default:
-                    return `${key}:${!!options[key]}`;
+            case "authorizationServer":
+                return `${key}:${options.authorizationServer?.toString(true)}`;
+            default:
+                return `${key}:${!!options[key]}`;
             }
-        }))
-            .sort()
-            .join(', ');
+        })).sort().join(", ");
         let singlerKey;
         if (isAuthenticationWwwAuthenticateRequest(scopesOrRequest)) {
             const challenge = scopesOrRequest;
             const challengeStr = challenge.wwwAuthenticate;
-            const scopesStr = challenge.fallbackScopes ? [...challenge.fallbackScopes].sort().join(' ') : '';
+            const scopesStr = challenge.fallbackScopes ? [...challenge.fallbackScopes].sort().join(" ") : "";
             singlerKey = `${extensionId} ${providerId} challenge:${challengeStr} ${scopesStr} ${optionsStr}`;
-        }
-        else {
-            const sortedScopes = [...scopesOrRequest].sort().join(' ');
+        } else {
+            const sortedScopes = [...scopesOrRequest].sort().join(" ");
             singlerKey = `${extensionId} ${providerId} ${sortedScopes} ${optionsStr}`;
         }
         return await this._getSessionTaskSingler.getOrCreate(singlerKey, async () => {
@@ -96,11 +101,20 @@ let ExtHostAuthentication = class ExtHostAuthentication {
     registerAuthenticationProvider(id, label, provider, options) {
         void this._providerOperations.queue(id, async () => {
             if (this._authenticationProviders.get(id)) {
-                this._logService.error(`An authentication provider with id '${id}' is already registered. The existing provider will not be replaced.`);
+                this._logService.error(
+                    `An authentication provider with id '${id}' is already registered. The existing provider will not be replaced.`
+                );
                 return;
             }
             const listener = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(id, e));
-            this._authenticationProviders.set(id, { label, provider, disposable: listener, options: options ?? { supportsMultipleAccounts: false } });
+            this._authenticationProviders.set(id, {
+                label,
+                provider,
+                disposable: listener,
+                options: options ?? {
+                    supportsMultipleAccounts: false
+                }
+            });
             await this._proxy.$registerAuthenticationProvider({
                 id,
                 label,
@@ -154,7 +168,7 @@ let ExtHostAuthentication = class ExtHostAuthentication {
             const providerData = this._authenticationProviders.get(providerId);
             if (providerData) {
                 const provider = providerData.provider;
-                if (typeof provider.getSessionsFromChallenges === 'function') {
+                if (typeof provider.getSessionsFromChallenges === "function") {
                     options.authorizationServer = URI.revive(options.authorizationServer);
                     return await provider.getSessionsFromChallenges(constraint, options);
                 }
@@ -170,7 +184,7 @@ let ExtHostAuthentication = class ExtHostAuthentication {
             const providerData = this._authenticationProviders.get(providerId);
             if (providerData) {
                 const provider = providerData.provider;
-                if (typeof provider.createSessionFromChallenges === 'function') {
+                if (typeof provider.createSessionFromChallenges === "function") {
                     options.authorizationServer = URI.revive(options.authorizationServer);
                     return await provider.createSessionFromChallenges(constraint, options);
                 }
@@ -183,7 +197,13 @@ let ExtHostAuthentication = class ExtHostAuthentication {
     }
     $onDidChangeAuthenticationSessions(id, label, extensionIdFilter) {
         if (!id.startsWith(INTERNAL_AUTH_PROVIDER_PREFIX)) {
-            this._onDidChangeSessions.fire({ provider: { id, label }, extensionIdFilter });
+            this._onDidChangeSessions.fire({
+                provider: {
+                    id,
+                    label
+                },
+                extensionIdFilter
+            });
         }
         return Promise.resolve();
     }
@@ -196,16 +216,26 @@ let ExtHostAuthentication = class ExtHostAuthentication {
             }
         });
     }
-    async $registerDynamicAuthProvider(authorizationServerComponents, serverMetadata, resourceMetadata, clientId, clientSecret, initialTokens) {
+    async $registerDynamicAuthProvider(
+        authorizationServerComponents,
+        serverMetadata,
+        resourceMetadata,
+        clientId,
+        clientSecret,
+        initialTokens
+    ) {
         if (!clientId) {
             const authorizationServer = URI.revive(authorizationServerComponents);
             if (serverMetadata.registration_endpoint) {
                 try {
-                    const registration = await fetchDynamicRegistration(serverMetadata, this._initData.environment.appName, resourceMetadata?.scopes_supported);
+                    const registration = await fetchDynamicRegistration(
+                        serverMetadata,
+                        this._initData.environment.appName,
+                        resourceMetadata?.scopes_supported
+                    );
                     clientId = registration.client_id;
                     clientSecret = registration.client_secret;
-                }
-                catch (err) {
+                } catch (err) {
                     this._logService.warn(`Dynamic registration failed for ${( authorizationServer.toString())}: ${err.message}. Prompting user for client ID and client secret...`);
                 }
             }
@@ -213,30 +243,49 @@ let ExtHostAuthentication = class ExtHostAuthentication {
                 this._logService.info(`Prompting user for client registration details for ${( authorizationServer.toString())}`);
                 const clientDetails = await this._proxy.$promptForClientRegistration(( authorizationServer.toString()));
                 if (!clientDetails) {
-                    throw ( new Error('User did not provide client details'));
+                    throw ( new Error("User did not provide client details"));
                 }
                 clientId = clientDetails.clientId;
                 clientSecret = clientDetails.clientSecret;
                 this._logService.info(`User provided client registration for ${( authorizationServer.toString())}`);
                 if (clientSecret) {
                     this._logService.trace(`User provided client secret for ${( authorizationServer.toString())}`);
-                }
-                else {
+                } else {
                     this._logService.trace(`User did not provide client secret for ${( authorizationServer.toString())}`);
                 }
             }
         }
-        const provider = new this._dynamicAuthProviderCtor(this._extHostWindow, this._extHostUrls, this._initData, this._extHostProgress, this._extHostLoggerService, this._proxy, URI.revive(authorizationServerComponents), serverMetadata, resourceMetadata, clientId, clientSecret, this._onDidDynamicAuthProviderTokensChange, initialTokens || []);
+        const provider = new this._dynamicAuthProviderCtor(
+            this._extHostWindow,
+            this._extHostUrls,
+            this._initData,
+            this._extHostProgress,
+            this._extHostLoggerService,
+            this._proxy,
+            URI.revive(authorizationServerComponents),
+            serverMetadata,
+            resourceMetadata,
+            clientId,
+            clientSecret,
+            this._onDidDynamicAuthProviderTokensChange,
+            initialTokens || []
+        );
         await this._providerOperations.queue(provider.id, async () => {
             this._authenticationProviders.set(provider.id, {
                 label: provider.label,
                 provider,
-                disposable: Disposable.from(provider, provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(provider.id, e)), provider.onDidChangeClientId(() => this._proxy.$sendDidChangeDynamicProviderInfo({
-                    providerId: provider.id,
-                    clientId: provider.clientId,
-                    clientSecret: provider.clientSecret
-                }))),
-                options: { supportsMultipleAccounts: true }
+                disposable: Disposable.from(
+                    provider,
+                    provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(provider.id, e)),
+                    provider.onDidChangeClientId(() => this._proxy.$sendDidChangeDynamicProviderInfo({
+                        providerId: provider.id,
+                        clientId: provider.clientId,
+                        clientSecret: provider.clientSecret
+                    }))
+                ),
+                options: {
+                    supportsMultipleAccounts: true
+                }
             });
             await this._proxy.$registerDynamicAuthenticationProvider({
                 id: provider.id,
@@ -251,18 +300,14 @@ let ExtHostAuthentication = class ExtHostAuthentication {
         return provider.id;
     }
     async $onDidChangeDynamicAuthProviderTokens(authProviderId, clientId, tokens) {
-        this._onDidDynamicAuthProviderTokensChange.fire({ authProviderId, clientId, tokens });
+        this._onDidDynamicAuthProviderTokensChange.fire({
+            authProviderId,
+            clientId,
+            tokens
+        });
     }
 };
-ExtHostAuthentication = ( __decorate([
-    ( __param(0, IExtHostRpcService)),
-    ( __param(1, IExtHostInitDataService)),
-    ( __param(2, IExtHostWindow)),
-    ( __param(3, IExtHostUrlsService)),
-    ( __param(4, IExtHostProgress)),
-    ( __param(5, ILoggerService)),
-    ( __param(6, ILogService))
-], ExtHostAuthentication));
+ExtHostAuthentication = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, IExtHostInitDataService)), ( __param(2, IExtHostWindow)), ( __param(3, IExtHostUrlsService)), ( __param(4, IExtHostProgress)), ( __param(5, ILoggerService)), ( __param(6, ILogService))], ExtHostAuthentication));
 class TaskSingler {
     constructor() {
         this._inFlightPromises = ( new Map());
@@ -278,7 +323,21 @@ class TaskSingler {
     }
 }
 let DynamicAuthProvider = class DynamicAuthProvider {
-    constructor(_extHostWindow, _extHostUrls, _initData, _extHostProgress, loggerService, _proxy, authorizationServer, _serverMetadata, _resourceMetadata, _clientId, _clientSecret, onDidDynamicAuthProviderTokensChange, initialTokens) {
+    constructor(
+        _extHostWindow,
+        _extHostUrls,
+        _initData,
+        _extHostProgress,
+        loggerService,
+        _proxy,
+        authorizationServer,
+        _serverMetadata,
+        _resourceMetadata,
+        _clientId,
+        _clientSecret,
+        onDidDynamicAuthProviderTokensChange,
+        initialTokens
+    ) {
         this._extHostWindow = _extHostWindow;
         this._extHostUrls = _extHostUrls;
         this._initData = _initData;
@@ -294,25 +353,25 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         this._onDidChangeClientId = ( new Emitter());
         this.onDidChangeClientId = this._onDidChangeClientId.event;
         const stringifiedServer = ( authorizationServer.toString(true));
-        this.id = _resourceMetadata?.resource
-            ? stringifiedServer + ' ' + _resourceMetadata?.resource
-            : stringifiedServer;
+        this.id = _resourceMetadata?.resource ? stringifiedServer + " " + _resourceMetadata?.resource : stringifiedServer;
         this.label = _resourceMetadata?.resource_name ?? this.authorizationServer.authority;
-        this._logger = loggerService.createLogger(this.id, { name: `Auth: ${this.label}` });
+        this._logger = loggerService.createLogger(this.id, {
+            name: `Auth: ${this.label}`
+        });
         this._disposable = ( new DisposableStore());
         this._disposable.add(this._onDidChangeSessions);
-        const scopedEvent = Event.chain(onDidDynamicAuthProviderTokensChange.event, $ => ( $
-            .filter(e => e.authProviderId === this.id && e.clientId === _clientId)
-            .map(e => e.tokens)));
+        const scopedEvent = Event.chain(onDidDynamicAuthProviderTokensChange.event, $ => ( $.filter(e => e.authProviderId === this.id && e.clientId === _clientId).map(e => e.tokens)));
         this._tokenStore = this._disposable.add(( new TokenStore({
             onDidChange: scopedEvent,
-            set: (tokens) => _proxy.$setSessionsForDynamicAuthProvider(this.id, this.clientId, tokens),
+            set: tokens => _proxy.$setSessionsForDynamicAuthProvider(this.id, this.clientId, tokens)
         }, initialTokens, this._logger)));
-        this._disposable.add(this._tokenStore.onDidChangeSessions(e => this._onDidChangeSessions.fire(e)));
+        this._disposable.add(
+            this._tokenStore.onDidChangeSessions(e => this._onDidChangeSessions.fire(e))
+        );
         this._createFlows = [];
         if (_serverMetadata.authorization_endpoint) {
             this._createFlows.push({
-                label: ( localize(2684, "URL Handler")),
+                label: ( localize(2687, "URL Handler")),
                 handler: (scopes, progress, token) => this._createWithUrlHandler(scopes, progress, token)
             });
         }
@@ -324,12 +383,12 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         return this._clientSecret;
     }
     async getSessions(scopes, _options) {
-        this._logger.info(`Getting sessions for scopes: ${scopes?.join(' ') ?? 'all'}`);
+        this._logger.info(`Getting sessions for scopes: ${scopes?.join(" ") ?? "all"}`);
         if (!scopes) {
             return this._tokenStore.sessions;
         }
         const sortedScopes = [...scopes].sort();
-        const scopeStr = scopes.join(' ');
+        const scopeStr = scopes.join(" ");
         let sessions = this._tokenStore.sessions.filter(session => equals([...session.scopes].sort(), sortedScopes));
         this._logger.info(`Found ${sessions.length} sessions for scopes: ${scopeStr}`);
         if (sessions.length) {
@@ -345,26 +404,32 @@ let DynamicAuthProvider = class DynamicAuthProvider {
                         this._logger.info(`Token for session ${session.id} is about to expire, refreshing...`);
                         removedTokens.push(token);
                         if (!token.refresh_token) {
-                            this._logger.warn(`No refresh token available for scopes ${session.scopes.join(' ')}. Throwing away token.`);
+                            this._logger.warn(
+                                `No refresh token available for scopes ${session.scopes.join(" ")}. Throwing away token.`
+                            );
                             continue;
                         }
                         try {
                             const newToken = await this.exchangeRefreshTokenForToken(token.refresh_token);
                             if (newToken.scope !== scopeStr) {
-                                this._logger.warn(`Token scopes '${newToken.scope}' do not match requested scopes '${scopeStr}'. Overwriting token with what was requested...`);
+                                this._logger.warn(
+                                    `Token scopes '${newToken.scope}' do not match requested scopes '${scopeStr}'. Overwriting token with what was requested...`
+                                );
                                 newToken.scope = scopeStr;
                             }
-                            this._logger.info(`Successfully created a new token for scopes ${session.scopes.join(' ')}.`);
+                            this._logger.info(`Successfully created a new token for scopes ${session.scopes.join(" ")}.`);
                             newTokens.push(newToken);
-                        }
-                        catch (err) {
+                        } catch (err) {
                             this._logger.error(`Failed to refresh token: ${err}`);
                         }
                     }
                 }
             }
             if (newTokens.length || removedTokens.length) {
-                this._tokenStore.update({ added: newTokens, removed: removedTokens });
+                this._tokenStore.update({
+                    added: newTokens,
+                    removed: removedTokens
+                });
                 sessions = this._tokenStore.sessions.filter(session => equals([...session.scopes].sort(), sortedScopes));
             }
             this._logger.info(`Found ${sessions.length} sessions for scopes: ${scopeStr}`);
@@ -373,34 +438,36 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         return [];
     }
     async createSession(scopes, _options) {
-        this._logger.info(`Creating session for scopes: ${scopes.join(' ')}`);
+        this._logger.info(`Creating session for scopes: ${scopes.join(" ")}`);
         let token;
         for (let i = 0; i < this._createFlows.length; i++) {
-            const { handler } = this._createFlows[i];
+            const {
+                handler
+            } = this._createFlows[i];
             try {
-                token = await this._extHostProgress.withProgressFromSource({ label: this.label, id: this.id }, {
+                token = await this._extHostProgress.withProgressFromSource({
+                    label: this.label,
+                    id: this.id
+                }, {
                     location: ProgressLocation.Notification,
-                    title: ( localize(2685, "Authenticating to '{0}'", this.label)),
+                    title: ( localize(2688, "Authenticating to '{0}'", this.label)),
                     cancellable: true
                 }, (progress, token) => handler(scopes, progress, token));
                 if (token) {
                     break;
                 }
-            }
-            catch (err) {
+            } catch (err) {
                 const nextMode = this._createFlows[i + 1]?.label;
                 if (!nextMode) {
                     break;
                 }
-                const message = isCancellationError(err)
-                    ? ( localize(
-                    2686,
+                const message = isCancellationError(err) ? ( localize(
+                    2689,
                     "Having trouble authenticating to '{0}'? Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
-                ))
-                    : ( localize(
-                    2687,
+                )) : ( localize(
+                    2690,
                     "You have not yet finished authenticating to '{0}'. Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
@@ -413,15 +480,25 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             }
         }
         if (!token) {
-            throw ( new Error('Failed to create authentication token'));
-        }
-        if (token.scope !== scopes.join(' ')) {
-            this._logger.warn(`Token scopes '${token.scope}' do not match requested scopes '${scopes.join(' ')}'. Overwriting token with what was requested...`);
-            token.scope = scopes.join(' ');
-        }
-        this._tokenStore.update({ added: [{ ...token, created_at: Date.now() }], removed: [] });
+            throw ( new Error("Failed to create authentication token"));
+        }
+        if (token.scope !== scopes.join(" ")) {
+            this._logger.warn(
+                `Token scopes '${token.scope}' do not match requested scopes '${scopes.join(" ")}'. Overwriting token with what was requested...`
+            );
+            token.scope = scopes.join(" ");
+        }
+        this._tokenStore.update({
+            added: [{
+                ...token,
+                created_at: Date.now()
+            }],
+            removed: []
+        });
         const session = this._tokenStore.sessions.find(t => t.accessToken === token.access_token);
-        this._logger.info(`Created ${token.refresh_token ? 'refreshable' : 'non-refreshable'} session for scopes: ${token.scope}${token.expires_in ? ` that expires in ${token.expires_in} seconds` : ''}`);
+        this._logger.info(
+            `Created ${token.refresh_token ? "refreshable" : "non-refreshable"} session for scopes: ${token.scope}${token.expires_in ? ` that expires in ${token.expires_in} seconds` : ""}`
+        );
         return session;
     }
     async removeSession(sessionId) {
@@ -436,18 +513,23 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             this._logger.error(`Failed to retrieve token for removed session: ${session.id}`);
             return;
         }
-        this._tokenStore.update({ added: [], removed: [token] });
-        this._logger.info(`Removed token for session: ${session.id} with scopes: ${session.scopes.join(' ')}`);
+        this._tokenStore.update({
+            added: [],
+            removed: [token]
+        });
+        this._logger.info(
+            `Removed token for session: ${session.id} with scopes: ${session.scopes.join(" ")}`
+        );
     }
     dispose() {
         this._disposable.dispose();
     }
     async _createWithUrlHandler(scopes, progress, token) {
         if (!this._serverMetadata.authorization_endpoint) {
-            throw ( new Error('Authorization Endpoint required'));
+            throw ( new Error("Authorization Endpoint required"));
         }
         if (!this._serverMetadata.token_endpoint) {
-            throw ( new Error('Token endpoint not available in server metadata'));
+            throw ( new Error("Token endpoint not available in server metadata"));
         }
         const codeVerifier = this.generateRandomString(64);
         const codeChallenge = await this.generateCodeChallenge(codeVerifier);
@@ -458,25 +540,24 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         let state;
         try {
             state = await this._extHostUrls.createAppUri(callbackUri);
-        }
-        catch (error) {
+        } catch (error) {
             throw ( new Error(`Failed to create external URI: ${error}`));
         }
         const authorizationUrl = ( new URL(this._serverMetadata.authorization_endpoint));
-        authorizationUrl.searchParams.append('client_id', this._clientId);
-        authorizationUrl.searchParams.append('response_type', 'code');
-        authorizationUrl.searchParams.append('state', ( state.toString()));
-        authorizationUrl.searchParams.append('code_challenge', codeChallenge);
-        authorizationUrl.searchParams.append('code_challenge_method', 'S256');
-        const scopeString = scopes.join(' ');
+        authorizationUrl.searchParams.append("client_id", this._clientId);
+        authorizationUrl.searchParams.append("response_type", "code");
+        authorizationUrl.searchParams.append("state", ( state.toString()));
+        authorizationUrl.searchParams.append("code_challenge", codeChallenge);
+        authorizationUrl.searchParams.append("code_challenge_method", "S256");
+        const scopeString = scopes.join(" ");
         if (scopeString) {
-            authorizationUrl.searchParams.append('scope', scopeString);
+            authorizationUrl.searchParams.append("scope", scopeString);
         }
         if (this._resourceMetadata?.resource) {
-            authorizationUrl.searchParams.append('resource', this._resourceMetadata.resource);
+            authorizationUrl.searchParams.append("resource", this._resourceMetadata.resource);
         }
-        const redirectUri = 'https://vscode.dev/redirect';
-        authorizationUrl.searchParams.append('redirect_uri', redirectUri);
+        const redirectUri = "https://vscode.dev/redirect";
+        authorizationUrl.searchParams.append("redirect_uri", redirectUri);
         const promise = this.waitForAuthorizationCode(callbackUri);
         this._logger.info(`Opening authorization URL for scopes: ${scopeString}`);
         this._logger.trace(`Authorization URL: ${( authorizationUrl.toString())}`);
@@ -485,16 +566,15 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new CancellationError());
         }
         progress.report({
-            message: ( localize(2688, "Complete the authentication in the browser window that has opened.")),
+            message: ( localize(2691, "Complete the authentication in the browser window that has opened."))
         });
         let code;
         try {
             const response = await raceCancellationError(promise, token);
             code = response.code;
-        }
-        catch (err) {
+        } catch (err) {
             if (isCancellationError(err)) {
-                this._logger.info('Authorization code request was cancelled by the user.');
+                this._logger.info("Authorization code request was cancelled by the user.");
                 throw err;
             }
             this._logger.error(`Failed to receive authorization code: ${err}`);
@@ -507,59 +587,54 @@ let DynamicAuthProvider = class DynamicAuthProvider {
     generateRandomString(length) {
         const array = ( new Uint8Array(length));
         crypto.getRandomValues(array);
-        return ( Array.from(array)
-            .map(b => ( b.toString(16)).padStart(2, '0')))
-            .join('')
-            .substring(0, length);
+        return ( Array.from(array).map(b => ( b.toString(16)).padStart(2, "0"))).join("").substring(0, length);
     }
     async generateCodeChallenge(codeVerifier) {
         const encoder = ( new TextEncoder());
         const data = encoder.encode(codeVerifier);
-        const digest = await crypto.subtle.digest('SHA-256', data);
-        return encodeBase64(VSBuffer.wrap(( new Uint8Array(digest))), false, false)
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
+        const digest = await crypto.subtle.digest("SHA-256", data);
+        return encodeBase64(VSBuffer.wrap(( new Uint8Array(digest))), false, false).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
     }
     async waitForAuthorizationCode(expectedState) {
         const result = await this._proxy.$waitForUriHandler(expectedState);
-        const codeMatch = /[?&]code=([^&]+)/.exec(result.query || '');
+        const codeMatch = /[?&]code=([^&]+)/.exec(result.query || "");
         if (!codeMatch || codeMatch.length < 2) {
-            throw ( new Error('Authentication failed: No authorization code received'));
+            throw ( new Error("Authentication failed: No authorization code received"));
         }
-        return { code: codeMatch[1] };
+        return {
+            code: codeMatch[1]
+        };
     }
     async exchangeCodeForToken(code, codeVerifier, redirectUri) {
         if (!this._serverMetadata.token_endpoint) {
-            throw ( new Error('Token endpoint not available in server metadata'));
+            throw ( new Error("Token endpoint not available in server metadata"));
         }
         const tokenRequest = ( new URLSearchParams());
-        tokenRequest.append('client_id', this._clientId);
-        tokenRequest.append('grant_type', 'authorization_code');
-        tokenRequest.append('code', code);
-        tokenRequest.append('redirect_uri', redirectUri);
-        tokenRequest.append('code_verifier', codeVerifier);
+        tokenRequest.append("client_id", this._clientId);
+        tokenRequest.append("grant_type", "authorization_code");
+        tokenRequest.append("code", code);
+        tokenRequest.append("redirect_uri", redirectUri);
+        tokenRequest.append("code_verifier", codeVerifier);
         if (this._resourceMetadata?.resource) {
-            tokenRequest.append('resource', this._resourceMetadata.resource);
+            tokenRequest.append("resource", this._resourceMetadata.resource);
         }
         if (this._clientSecret) {
-            tokenRequest.append('client_secret', this._clientSecret);
+            tokenRequest.append("client_secret", this._clientSecret);
         }
-        this._logger.info('Exchanging authorization code for token...');
+        this._logger.info("Exchanging authorization code for token...");
         this._logger.trace(`Url: ${this._serverMetadata.token_endpoint}`);
         this._logger.trace(`Token request body: ${( tokenRequest.toString())}`);
         let response;
         try {
             response = await fetch(this._serverMetadata.token_endpoint, {
-                method: 'POST',
+                method: "POST",
                 headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                    'Accept': 'application/json'
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Accept": "application/json"
                 },
                 body: ( tokenRequest.toString())
             });
-        }
-        catch (err) {
+        } catch (err) {
             this._logger.error(`Failed to exchange authorization code for token: ${err}`);
             throw ( new Error(`Failed to exchange authorization code for token: ${err}`));
         }
@@ -573,8 +648,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         if (isAuthorizationTokenResponse(result)) {
             this._logger.info(`Successfully exchanged authorization code for token.`);
             return result;
-        }
-        else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
+        } else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
             this._logger.warn(`Client ID (${this._clientId}) was invalid, generated a new one.`);
             await this._generateNewClientId();
             throw ( new Error(`Client ID was invalid, generated a new one. Please try again.`));
@@ -583,23 +657,23 @@ let DynamicAuthProvider = class DynamicAuthProvider {
     }
     async exchangeRefreshTokenForToken(refreshToken) {
         if (!this._serverMetadata.token_endpoint) {
-            throw ( new Error('Token endpoint not available in server metadata'));
+            throw ( new Error("Token endpoint not available in server metadata"));
         }
         const tokenRequest = ( new URLSearchParams());
-        tokenRequest.append('client_id', this._clientId);
-        tokenRequest.append('grant_type', 'refresh_token');
-        tokenRequest.append('refresh_token', refreshToken);
+        tokenRequest.append("client_id", this._clientId);
+        tokenRequest.append("grant_type", "refresh_token");
+        tokenRequest.append("refresh_token", refreshToken);
         if (this._resourceMetadata?.resource) {
-            tokenRequest.append('resource', this._resourceMetadata.resource);
+            tokenRequest.append("resource", this._resourceMetadata.resource);
         }
         if (this._clientSecret) {
-            tokenRequest.append('client_secret', this._clientSecret);
+            tokenRequest.append("client_secret", this._clientSecret);
         }
         const response = await fetch(this._serverMetadata.token_endpoint, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Accept': 'application/json'
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Accept": "application/json"
             },
             body: ( tokenRequest.toString())
         });
@@ -607,10 +681,9 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         if (isAuthorizationTokenResponse(result)) {
             return {
                 ...result,
-                created_at: Date.now(),
+                created_at: Date.now()
             };
-        }
-        else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
+        } else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
             this._logger.warn(`Client ID (${this._clientId}) was invalid, generated a new one.`);
             await this._generateNewClientId();
             throw ( new Error(`Client ID was invalid, generated a new one. Please try again.`));
@@ -619,43 +692,38 @@ let DynamicAuthProvider = class DynamicAuthProvider {
     }
     async _generateNewClientId() {
         try {
-            const registration = await fetchDynamicRegistration(this._serverMetadata, this._initData.environment.appName, this._resourceMetadata?.scopes_supported);
+            const registration = await fetchDynamicRegistration(
+                this._serverMetadata,
+                this._initData.environment.appName,
+                this._resourceMetadata?.scopes_supported
+            );
             this._clientId = registration.client_id;
             this._clientSecret = registration.client_secret;
             this._onDidChangeClientId.fire();
-        }
-        catch (err) {
+        } catch (err) {
             this._logger.info(`Dynamic registration failed for ${( this.authorizationServer.toString())}: ${err}. Prompting user for client ID and client secret.`);
             try {
                 const clientDetails = await this._proxy.$promptForClientRegistration(( this.authorizationServer.toString()));
                 if (!clientDetails) {
-                    throw ( new Error('User did not provide client details'));
+                    throw ( new Error("User did not provide client details"));
                 }
                 this._clientId = clientDetails.clientId;
                 this._clientSecret = clientDetails.clientSecret;
                 this._logger.info(`User provided client ID for ${( this.authorizationServer.toString())}`);
                 if (clientDetails.clientSecret) {
                     this._logger.info(`User provided client secret for ${( this.authorizationServer.toString())}`);
-                }
-                else {
+                } else {
                     this._logger.info(`User did not provide client secret for ${( this.authorizationServer.toString())} (optional)`);
                 }
                 this._onDidChangeClientId.fire();
-            }
-            catch (promptErr) {
+            } catch (promptErr) {
                 this._logger.error(`Failed to fetch new client ID and user did not provide one: ${err}`);
                 throw ( new Error(`Failed to fetch new client ID and user did not provide one: ${err}`));
             }
         }
     }
 };
-DynamicAuthProvider = ( __decorate([
-    ( __param(0, IExtHostWindow)),
-    ( __param(1, IExtHostUrlsService)),
-    ( __param(2, IExtHostInitDataService)),
-    ( __param(3, IExtHostProgress)),
-    ( __param(4, ILoggerService))
-], DynamicAuthProvider));
+DynamicAuthProvider = ( __decorate([( __param(0, IExtHostWindow)), ( __param(1, IExtHostUrlsService)), ( __param(2, IExtHostInitDataService)), ( __param(3, IExtHostProgress)), ( __param(4, ILoggerService))], DynamicAuthProvider));
 class TokenStore {
     constructor(_persistence, initialTokens, _logger) {
         this._persistence = _persistence;
@@ -663,10 +731,14 @@ class TokenStore {
         this._onDidChangeSessions = ( new Emitter());
         this.onDidChangeSessions = this._onDidChangeSessions.event;
         this._disposable = ( new DisposableStore());
-        this._tokensObservable = observableValue('tokens', initialTokens);
-        this._sessionsObservable = derivedOpts({ equalsFn: (a, b) => equals(a, b, (a, b) => a.accessToken === b.accessToken) }, (reader) => ( this._tokensObservable.read(reader).map(t => this._getSessionFromToken(t))));
+        this._tokensObservable = observableValue("tokens", initialTokens);
+        this._sessionsObservable = derivedOpts({
+            equalsFn: (a, b) => equals(a, b, (a, b) => a.accessToken === b.accessToken)
+        }, reader => ( this._tokensObservable.read(reader).map(t => this._getSessionFromToken(t))));
         this._disposable.add(this._registerChangeEventAutorun());
-        this._disposable.add(this._persistence.onDidChange((tokens) => this._tokensObservable.set(tokens, undefined)));
+        this._disposable.add(
+            this._persistence.onDidChange(tokens => this._tokensObservable.set(tokens, undefined))
+        );
     }
     get tokens() {
         return this._tokensObservable.get();
@@ -677,7 +749,12 @@ class TokenStore {
     dispose() {
         this._disposable.dispose();
     }
-    update({ added, removed }) {
+    update(
+        {
+            added,
+            removed
+        }
+    ) {
         this._logger.trace(`Updating tokens: added ${added.length}, removed ${removed.length}`);
         const currentTokens = [...this._tokensObservable.get()];
         for (const token of removed) {
@@ -690,8 +767,7 @@ class TokenStore {
             const index = currentTokens.findIndex(t => t.access_token === token.access_token);
             if (index === -1) {
                 currentTokens.push(token);
-            }
-            else {
+            } else {
                 currentTokens[index] = token;
             }
         }
@@ -703,15 +779,15 @@ class TokenStore {
     }
     _registerChangeEventAutorun() {
         let previousSessions = [];
-        return autorun((reader) => {
-            this._logger.trace('Checking for session changes...');
+        return autorun(reader => {
+            this._logger.trace("Checking for session changes...");
             const currentSessions = this._sessionsObservable.read(reader);
             if (previousSessions === currentSessions) {
-                this._logger.trace('No session changes detected.');
+                this._logger.trace("No session changes detected.");
                 return;
             }
             if (!currentSessions || currentSessions.length === 0) {
-                this._logger.trace('All sessions removed.');
+                this._logger.trace("All sessions removed.");
                 if (previousSessions.length > 0) {
                     this._onDidChangeSessions.fire({
                         added: [],
@@ -738,7 +814,11 @@ class TokenStore {
             }
             if (added.length > 0 || removed.length > 0) {
                 this._logger.trace(`Sessions changed: added ${added.length}, removed ${removed.length}`);
-                this._onDidChangeSessions.fire({ added, removed, changed: [] });
+                this._onDidChangeSessions.fire({
+                    added,
+                    removed,
+                    changed: []
+                });
             }
             previousSessions = currentSessions;
         });
@@ -748,28 +828,20 @@ class TokenStore {
         if (token.id_token) {
             try {
                 claims = getClaimsFromJWT(token.id_token);
-            }
-            catch (e) {
-            }
+            } catch (e) {}
         }
         if (!claims) {
             try {
                 claims = getClaimsFromJWT(token.access_token);
-            }
-            catch (e) {
-            }
+            } catch (e) {}
         }
-        const scopes = token.scope
-            ? token.scope.split(' ')
-            : claims?.scope
-                ? claims.scope.split(' ')
-                : [];
+        const scopes = token.scope ? token.scope.split(" ") : claims?.scope ? claims.scope.split(" ") : [];
         return {
             id: ( stringHash(token.access_token, 0).toString()),
             accessToken: token.access_token,
             account: {
-                id: claims?.sub || 'unknown',
-                label: claims?.preferred_username || claims?.name || claims?.email || 'MCP',
+                id: claims?.sub || "unknown",
+                label: claims?.preferred_username || claims?.name || claims?.email || "MCP"
             },
             scopes: scopes,
             idToken: token.id_token