@codingame/monaco-vscode-api 3.2.2 → 4.0.0

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -1,65 +1,13 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { fromNow } from '../../../../base/common/date.js';
 import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, MutableDisposable, DisposableMap, isDisposable, dispose, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap, isDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from '../../../../base/common/strings.js';
 import { isString } from '../../../../base/common/types.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
-import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
-import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { Severity } from '../../../../platform/notification/common/notification.js';
-import { IProductService } from '../../../../platform/product/common/productService.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IActivityService, NumberBadge } from '../../activity/common/activity.js';
-import { IAuthenticationService } from '../common/authentication.js';
-import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
-import { Extensions } from '../../extensionManagement/common/extensionFeatures.js';
+import { IAuthenticationAccessService } from './authenticationAccessService.js';
+import '../../../../platform/instantiation/common/instantiation.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
-import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 function getAuthenticationProviderActivationEvent(id) { return `onAuthenticationRequest:${id}`; }
-function readAccountUsages(storageService, providerId, accountName) {
-    const accountKey = `${providerId}-${accountName}-usages`;
-    const storedUsages = storageService.get(accountKey, -1 );
-    let usages = [];
-    if (storedUsages) {
-        try {
-            usages = JSON.parse(storedUsages);
-        }
-        catch (e) {
-        }
-    }
-    return usages;
-}
-function removeAccountUsage(storageService, providerId, accountName) {
-    const accountKey = `${providerId}-${accountName}-usages`;
-    storageService.remove(accountKey, -1 );
-}
-function addAccountUsage(storageService, providerId, accountName, extensionId, extensionName) {
-    const accountKey = `${providerId}-${accountName}-usages`;
-    const usages = readAccountUsages(storageService, providerId, accountName);
-    const existingUsageIndex = usages.findIndex(usage => usage.extensionId === extensionId);
-    if (existingUsageIndex > -1) {
-        usages.splice(existingUsageIndex, 1, {
-            extensionId,
-            extensionName,
-            lastUsed: Date.now()
-        });
-    }
-    else {
-        usages.push({
-            extensionId,
-            extensionName,
-            lastUsed: Date.now()
-        });
-    }
-    storageService.store(accountKey, JSON.stringify(usages), -1 , 1 );
-}
 async function getCurrentAuthenticationSessionInfo(secretStorageService, productService) {
     const authenticationSessionValue = await secretStorageService.get(`${productService.urlProtocol}.loginAccount`);
     if (authenticationSessionValue) {
@@ -78,132 +26,10 @@ async function getCurrentAuthenticationSessionInfo(secretStorageService, product
     }
     return undefined;
 }
-const SCOPESLIST_SEPARATOR = ' ';
-CommandsRegistry.registerCommand('workbench.getCodeExchangeProxyEndpoints', function (accessor, _) {
-    const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
-    return environmentService.options?.codeExchangeProxyEndpoints;
-});
-const authenticationDefinitionSchema = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-        id: {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'authentication.id',
-                'The id of the authentication provider.'
-            ))
-        },
-        label: {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'authentication.label',
-                'The human readable name of the authentication provider.'
-            )),
-        }
-    }
-};
-const authenticationExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'authentication',
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/authentication/browser/authenticationService',
-            { key: 'authenticationExtensionPoint', comment: [`'Contributes' means adds here`] },
-            'Contributes authentication'
-        )),
-        type: 'array',
-        items: authenticationDefinitionSchema
-    },
-    activationEventsGenerator: (authenticationProviders, result) => {
-        for (const authenticationProvider of authenticationProviders) {
-            if (authenticationProvider.id) {
-                result.push(`onAuthenticationRequest:${authenticationProvider.id}`);
-            }
-        }
-    }
-});
-class AuthenticationDataRenderer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 'table';
-    }
-    shouldRender(manifest) {
-        return !!manifest.contributes?.authentication;
-    }
-    render(manifest) {
-        const authentication = manifest.contributes?.authentication || [];
-        if (!authentication.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
-        }
-        const headers = [
-            ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'authenticationlabel',
-                "Label"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'authenticationid',
-                "ID"
-            )),
-        ];
-        const rows = ( authentication
-            .sort((a, b) => a.label.localeCompare(b.label))
-            .map(auth => {
-            return [
-                auth.label,
-                auth.id,
-            ];
-        }));
-        return {
-            data: {
-                headers,
-                rows
-            },
-            dispose: () => { }
-        };
-    }
-}
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'authentication',
-    label: ( localizeWithPath(
-        'vs/workbench/services/authentication/browser/authenticationService',
-        'authentication',
-        "Authentication"
-    )),
-    access: {
-        canToggle: false
-    },
-    renderer: ( new SyncDescriptor(AuthenticationDataRenderer)),
-});
-let placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-    command: {
-        id: 'noAuthenticationProviders',
-        title: ( localizeWithPath(
-            'vs/workbench/services/authentication/browser/authenticationService',
-            'authentication.Placeholder',
-            "No accounts requested yet..."
-        )),
-        precondition: ( ContextKeyExpr.false())
-    },
-}));
 let AuthenticationService = class AuthenticationService extends Disposable {
-    constructor(activityService, extensionService, storageService, dialogService, quickInputService, productService, environmentService) {
+    constructor(_extensionService, authenticationAccessService) {
         super();
-        this.activityService = activityService;
-        this.extensionService = extensionService;
-        this.storageService = storageService;
-        this.dialogService = dialogService;
-        this.quickInputService = quickInputService;
-        this.productService = productService;
-        this._signInRequestItems = ( new Map());
-        this._sessionAccessRequestItems = ( new Map());
-        this._accountBadgeDisposable = this._register(( new MutableDisposable()));
-        this._authenticationProviders = ( new Map());
-        this._authenticationProviderDisposables = this._register(( new DisposableMap()));
-        this.declaredProviders = [];
+        this._extensionService = _extensionService;
         this._onDidRegisterAuthenticationProvider = this._register(( new Emitter()));
         this.onDidRegisterAuthenticationProvider = this._onDidRegisterAuthenticationProvider.event;
         this._onDidUnregisterAuthenticationProvider = this._register(( new Emitter()));
@@ -212,57 +38,43 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         this.onDidChangeSessions = this._onDidChangeSessions.event;
         this._onDidChangeDeclaredProviders = this._register(( new Emitter()));
         this.onDidChangeDeclaredProviders = this._onDidChangeDeclaredProviders.event;
-        this._onDidChangeExtensionSessionAccess = this._register(( new Emitter()));
-        this.onDidChangeExtensionSessionAccess = this._onDidChangeExtensionSessionAccess.event;
-        environmentService.options?.authenticationProviders?.forEach(provider => this.registerAuthenticationProvider(provider.id, provider));
-        authenticationExtPoint.setHandler((extensions, { added, removed }) => {
-            added.forEach(point => {
-                for (const provider of point.value) {
-                    if (isFalsyOrWhitespace(provider.id)) {
-                        point.collector.error(( localizeWithPath(
-                            'vs/workbench/services/authentication/browser/authenticationService',
-                            'authentication.missingId',
-                            'An authentication contribution must specify an id.'
-                        )));
-                        continue;
-                    }
-                    if (isFalsyOrWhitespace(provider.label)) {
-                        point.collector.error(( localizeWithPath(
-                            'vs/workbench/services/authentication/browser/authenticationService',
-                            'authentication.missingLabel',
-                            'An authentication contribution must specify a label.'
-                        )));
-                        continue;
-                    }
-                    if (!( this.declaredProviders.some(p => p.id === provider.id))) {
-                        this.declaredProviders.push(provider);
-                    }
-                    else {
-                        point.collector.error(( localizeWithPath(
-                            'vs/workbench/services/authentication/browser/authenticationService',
-                            'authentication.idConflict',
-                            "This authentication id '{0}' has already been registered",
-                            provider.id
-                        )));
-                    }
-                }
-            });
-            const removedExtPoints = removed.flatMap(r => r.value);
-            removedExtPoints.forEach(point => {
-                const index = this.declaredProviders.findIndex(provider => provider.id === point.id);
-                if (index > -1) {
-                    this.declaredProviders.splice(index, 1);
+        this._authenticationProviders = ( new Map());
+        this._authenticationProviderDisposables = this._register(( new DisposableMap()));
+        this._declaredProviders = [];
+        this._register(authenticationAccessService.onDidChangeExtensionSessionAccess(e => {
+            this._onDidChangeSessions.fire({
+                providerId: e.providerId,
+                label: e.accountName,
+                event: {
+                    added: [],
+                    changed: [],
+                    removed: []
                 }
             });
-            this._onDidChangeDeclaredProviders.fire(this.declaredProviders);
-        });
+        }));
     }
-    getProviderIds() {
-        const providerIds = [];
-        this._authenticationProviders.forEach(provider => {
-            providerIds.push(provider.id);
-        });
-        return providerIds;
+    get declaredProviders() {
+        return this._declaredProviders;
+    }
+    registerDeclaredAuthenticationProvider(provider) {
+        if (isFalsyOrWhitespace(provider.id)) {
+            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.missingId', 'An authentication contribution must specify an id.'));
+        }
+        if (isFalsyOrWhitespace(provider.label)) {
+            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.missingLabel', 'An authentication contribution must specify a label.'));
+        }
+        if (( this.declaredProviders.some(p => p.id === provider.id))) {
+            throw new Error(localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.idConflict', "This authentication id '{0}' has already been registered", provider.id));
+        }
+        this._declaredProviders.push(provider);
+        this._onDidChangeDeclaredProviders.fire();
+    }
+    unregisterDeclaredAuthenticationProvider(id) {
+        const index = this.declaredProviders.findIndex(provider => provider.id === id);
+        if (index > -1) {
+            this.declaredProviders.splice(index, 1);
+        }
+        this._onDidChangeDeclaredProviders.fire();
     }
     isAuthenticationProviderRegistered(id) {
         return ( this._authenticationProviders.has(id));
@@ -270,394 +82,69 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     registerAuthenticationProvider(id, authenticationProvider) {
         this._authenticationProviders.set(id, authenticationProvider);
         const disposableStore = ( new DisposableStore());
-        disposableStore.add(authenticationProvider.onDidChangeSessions(e => this.sessionsUpdate(authenticationProvider, e)));
+        disposableStore.add(authenticationProvider.onDidChangeSessions(e => this._onDidChangeSessions.fire({
+            providerId: id,
+            label: authenticationProvider.label,
+            event: e
+        })));
         if (isDisposable(authenticationProvider)) {
             disposableStore.add(authenticationProvider);
         }
         this._authenticationProviderDisposables.set(id, disposableStore);
         this._onDidRegisterAuthenticationProvider.fire({ id, label: authenticationProvider.label });
-        if (placeholderMenuItem) {
-            placeholderMenuItem.dispose();
-            placeholderMenuItem = undefined;
-        }
     }
     unregisterAuthenticationProvider(id) {
         const provider = this._authenticationProviders.get(id);
         if (provider) {
             this._authenticationProviders.delete(id);
             this._onDidUnregisterAuthenticationProvider.fire({ id, label: provider.label });
-            const accessRequests = this._sessionAccessRequestItems.get(id) || {};
-            ( Object.keys(accessRequests)).forEach(extensionId => {
-                this.removeAccessRequest(id, extensionId);
-            });
         }
         this._authenticationProviderDisposables.deleteAndDispose(id);
-        if (!this._authenticationProviders.size) {
-            placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-                command: {
-                    id: 'noAuthenticationProviders',
-                    title: ( localizeWithPath(
-                        'vs/workbench/services/authentication/browser/authenticationService',
-                        'loading',
-                        "Loading..."
-                    )),
-                    precondition: ( ContextKeyExpr.false())
-                },
-            }));
-        }
-    }
-    async sessionsUpdate(provider, event) {
-        this._onDidChangeSessions.fire({ providerId: provider.id, label: provider.label, event });
-        if (event.added?.length) {
-            await this.updateNewSessionRequests(provider, event.added);
-        }
-        if (event.removed?.length) {
-            await this.updateAccessRequests(provider.id, event.removed);
-        }
-        this.updateBadgeCount();
-    }
-    async updateNewSessionRequests(provider, addedSessions) {
-        const existingRequestsForProvider = this._signInRequestItems.get(provider.id);
-        if (!existingRequestsForProvider) {
-            return;
-        }
-        ( Object.keys(existingRequestsForProvider)).forEach(requestedScopes => {
-            if (( addedSessions.some(
-                session => session.scopes.slice().join(SCOPESLIST_SEPARATOR) === requestedScopes
-            ))) {
-                const sessionRequest = existingRequestsForProvider[requestedScopes];
-                sessionRequest?.disposables.forEach(item => item.dispose());
-                delete existingRequestsForProvider[requestedScopes];
-                if (( Object.keys(existingRequestsForProvider)).length === 0) {
-                    this._signInRequestItems.delete(provider.id);
-                }
-                else {
-                    this._signInRequestItems.set(provider.id, existingRequestsForProvider);
-                }
-            }
-        });
-    }
-    async updateAccessRequests(providerId, removedSessions) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId);
-        if (providerRequests) {
-            ( Object.keys(providerRequests)).forEach(extensionId => {
-                removedSessions.forEach(removed => {
-                    const indexOfSession = providerRequests[extensionId].possibleSessions.findIndex(session => session.id === removed.id);
-                    if (indexOfSession) {
-                        providerRequests[extensionId].possibleSessions.splice(indexOfSession, 1);
-                    }
-                });
-                if (!providerRequests[extensionId].possibleSessions.length) {
-                    this.removeAccessRequest(providerId, extensionId);
-                }
-            });
-        }
-    }
-    updateBadgeCount() {
-        this._accountBadgeDisposable.clear();
-        let numberOfRequests = 0;
-        this._signInRequestItems.forEach(providerRequests => {
-            ( Object.keys(providerRequests)).forEach(request => {
-                numberOfRequests += providerRequests[request].requestingExtensionIds.length;
-            });
-        });
-        this._sessionAccessRequestItems.forEach(accessRequest => {
-            numberOfRequests += ( Object.keys(accessRequest)).length;
-        });
-        if (numberOfRequests > 0) {
-            const badge = ( new NumberBadge(numberOfRequests, () => ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'sign in',
-                "Sign in requested"
-            ))));
-            this._accountBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
-        }
-    }
-    removeAccessRequest(providerId, extensionId) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
-        if (providerRequests[extensionId]) {
-            dispose(providerRequests[extensionId].disposables);
-            delete providerRequests[extensionId];
-            this.updateBadgeCount();
-        }
-    }
-    isAccessAllowed(providerId, accountName, extensionId) {
-        const trustedExtensionAuthAccess = this.productService.trustedExtensionAuthAccess;
-        if (Array.isArray(trustedExtensionAuthAccess)) {
-            if (trustedExtensionAuthAccess.includes(extensionId)) {
-                return true;
-            }
-        }
-        else if (trustedExtensionAuthAccess?.[providerId]?.includes(extensionId)) {
-            return true;
-        }
-        const allowList = this.readAllowedExtensions(providerId, accountName);
-        const extensionData = allowList.find(extension => extension.id === extensionId);
-        if (!extensionData) {
-            return undefined;
-        }
-        return extensionData.allowed !== undefined
-            ? extensionData.allowed
-            : true;
-    }
-    updateAllowedExtension(providerId, accountName, extensionId, extensionName, isAllowed) {
-        const allowList = this.readAllowedExtensions(providerId, accountName);
-        const index = allowList.findIndex(extension => extension.id === extensionId);
-        if (index === -1) {
-            allowList.push({ id: extensionId, name: extensionName, allowed: isAllowed });
-        }
-        else {
-            allowList[index].allowed = isAllowed;
-        }
-        this.storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), -1 , 0 );
-    }
-    updateSessionPreference(providerId, extensionId, session) {
-        const key = `${extensionId}-${providerId}-${session.scopes.join(' ')}`;
-        this.storageService.store(key, session.id, 1 , 1 );
-        this.storageService.store(key, session.id, -1 , 1 );
     }
-    getSessionPreference(providerId, extensionId, scopes) {
-        const key = `${extensionId}-${providerId}-${scopes.join(' ')}`;
-        return this.storageService.get(key, 1 ) ?? this.storageService.get(key, -1 );
-    }
-    removeSessionPreference(providerId, extensionId, scopes) {
-        const key = `${extensionId}-${providerId}-${scopes.join(' ')}`;
-        this.storageService.remove(key, 1 );
-        this.storageService.remove(key, -1 );
-    }
-    async showGetSessionPrompt(providerId, accountName, extensionId, extensionName) {
-        const providerName = this.getLabel(providerId);
-        let SessionPromptChoice;
-        ( (function(SessionPromptChoice) {
-            SessionPromptChoice[SessionPromptChoice["Allow"] = 0] = "Allow";
-            SessionPromptChoice[SessionPromptChoice["Deny"] = 1] = "Deny";
-            SessionPromptChoice[SessionPromptChoice["Cancel"] = 2] = "Cancel";
-        })(SessionPromptChoice || (SessionPromptChoice = {})));
-        const { result } = await this.dialogService.prompt({
-            type: Severity.Info,
-            message: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'confirmAuthenticationAccess',
-                "The extension '{0}' wants to access the {1} account '{2}'.",
-                extensionName,
-                providerName,
-                accountName
-            )),
-            buttons: [
-                {
-                    label: ( localizeWithPath(
-                        'vs/workbench/services/authentication/browser/authenticationService',
-                        { key: 'allow', comment: ['&& denotes a mnemonic'] },
-                        "&&Allow"
-                    )),
-                    run: () => SessionPromptChoice.Allow
-                },
-                {
-                    label: ( localizeWithPath(
-                        'vs/workbench/services/authentication/browser/authenticationService',
-                        { key: 'deny', comment: ['&& denotes a mnemonic'] },
-                        "&&Deny"
-                    )),
-                    run: () => SessionPromptChoice.Deny
-                }
-            ],
-            cancelButton: {
-                run: () => SessionPromptChoice.Cancel
-            }
+    getProviderIds() {
+        const providerIds = [];
+        this._authenticationProviders.forEach(provider => {
+            providerIds.push(provider.id);
         });
-        if (result !== SessionPromptChoice.Cancel) {
-            this.updateAllowedExtension(providerId, accountName, extensionId, extensionName, result === SessionPromptChoice.Allow);
-            this.removeAccessRequest(providerId, extensionId);
-        }
-        return result === SessionPromptChoice.Allow;
-    }
-    async selectSession(providerId, extensionId, extensionName, scopes, availableSessions) {
-        return ( new Promise((resolve, reject) => {
-            if (!availableSessions.length) {
-                reject('No available sessions');
-            }
-            const quickPick = this.quickInputService.createQuickPick();
-            quickPick.ignoreFocusOut = true;
-            const items = ( availableSessions.map(session => {
-                return {
-                    label: session.account.label,
-                    session: session
-                };
-            }));
-            items.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/services/authentication/browser/authenticationService',
-                    'useOtherAccount',
-                    "Sign in to another account"
-                ))
-            });
-            const providerName = this.getLabel(providerId);
-            quickPick.items = items;
-            quickPick.title = ( localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', {
-                key: 'selectAccount',
-                comment: ['The placeholder {0} is the name of an extension. {1} is the name of the type of account, such as Microsoft or GitHub.']
-            }, "The extension '{0}' wants to access a {1} account", extensionName, providerName));
-            quickPick.placeholder = ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'getSessionPlateholder',
-                "Select an account for '{0}' to use or Esc to cancel",
-                extensionName
-            ));
-            quickPick.onDidAccept(async (_) => {
-                const session = quickPick.selectedItems[0].session ?? (await this.createSession(providerId, scopes));
-                const accountName = session.account.label;
-                this.updateAllowedExtension(providerId, accountName, extensionId, extensionName, true);
-                this.updateSessionPreference(providerId, extensionId, session);
-                this.removeAccessRequest(providerId, extensionId);
-                quickPick.dispose();
-                resolve(session);
-            });
-            quickPick.onDidHide(_ => {
-                if (!quickPick.selectedItems[0]) {
-                    reject('User did not consent to account access');
-                }
-                quickPick.dispose();
-            });
-            quickPick.show();
-        }));
-    }
-    async completeSessionAccessRequest(providerId, extensionId, extensionName, scopes) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
-        const existingRequest = providerRequests[extensionId];
-        if (!existingRequest) {
-            return;
-        }
-        const possibleSessions = existingRequest.possibleSessions;
-        const supportsMultipleAccounts = this.supportsMultipleAccounts(providerId);
-        let session;
-        if (supportsMultipleAccounts) {
-            try {
-                session = await this.selectSession(providerId, extensionId, extensionName, scopes, possibleSessions);
-            }
-            catch (_) {
-            }
-        }
-        else {
-            const approved = await this.showGetSessionPrompt(providerId, possibleSessions[0].account.label, extensionId, extensionName);
-            if (approved) {
-                session = possibleSessions[0];
-            }
-        }
-        if (session) {
-            addAccountUsage(this.storageService, providerId, session.account.label, extensionId, extensionName);
-            const providerName = this.getLabel(providerId);
-            this._onDidChangeSessions.fire({ providerId, label: providerName, event: { added: [], removed: [], changed: [session] } });
-        }
+        return providerIds;
     }
-    requestSessionAccess(providerId, extensionId, extensionName, scopes, possibleSessions) {
-        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
-        const hasExistingRequest = providerRequests[extensionId];
-        if (hasExistingRequest) {
-            return;
+    getProvider(id) {
+        if (( this._authenticationProviders.has(id))) {
+            return this._authenticationProviders.get(id);
         }
-        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '3_accessRequests',
-            command: {
-                id: `${providerId}${extensionId}Access`,
-                title: ( localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', {
-                    key: 'accessRequest',
-                    comment: [`The placeholder {0} will be replaced with an authentication provider''s label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count`]
-                }, "Grant access to {0} for {1}... (1)", this.getLabel(providerId), extensionName))
-            }
-        }));
-        const accessCommand = CommandsRegistry.registerCommand({
-            id: `${providerId}${extensionId}Access`,
-            handler: async (accessor) => {
-                const authenticationService = accessor.get(IAuthenticationService);
-                authenticationService.completeSessionAccessRequest(providerId, extensionId, extensionName, scopes);
-            }
-        });
-        providerRequests[extensionId] = { possibleSessions, disposables: [menuItem, accessCommand] };
-        this._sessionAccessRequestItems.set(providerId, providerRequests);
-        this.updateBadgeCount();
+        throw new Error(`No authentication provider '${id}' is currently registered.`);
     }
-    async requestNewSession(providerId, scopes, extensionId, extensionName) {
-        let provider = this._authenticationProviders.get(providerId);
-        if (!provider) {
-            await ( new Promise((resolve, _) => {
-                const dispose = this.onDidRegisterAuthenticationProvider(e => {
-                    if (e.id === providerId) {
-                        provider = this._authenticationProviders.get(providerId);
-                        dispose.dispose();
-                        resolve();
-                    }
-                });
-            }));
-        }
-        if (!provider) {
-            return;
-        }
-        const providerRequests = this._signInRequestItems.get(providerId);
-        const scopesList = scopes.join(SCOPESLIST_SEPARATOR);
-        const extensionHasExistingRequest = providerRequests
-            && providerRequests[scopesList]
-            && providerRequests[scopesList].requestingExtensionIds.includes(extensionId);
-        if (extensionHasExistingRequest) {
-            return;
-        }
-        const commandId = `${providerId}:${extensionId}:signIn${( Object.keys(providerRequests || [])).length}`;
-        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '2_signInRequests',
-            command: {
-                id: commandId,
-                title: ( localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', {
-                    key: 'signInRequest',
-                    comment: [`The placeholder {0} will be replaced with an authentication provider's label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count.`]
-                }, "Sign in with {0} to use {1} (1)", provider.label, extensionName))
-            }
-        }));
-        const signInCommand = CommandsRegistry.registerCommand({
-            id: commandId,
-            handler: async (accessor) => {
-                const authenticationService = accessor.get(IAuthenticationService);
-                const session = await authenticationService.createSession(providerId, scopes);
-                this.updateAllowedExtension(providerId, session.account.label, extensionId, extensionName, true);
-                this.updateSessionPreference(providerId, extensionId, session);
-            }
-        });
-        if (providerRequests) {
-            const existingRequest = providerRequests[scopesList] || { disposables: [], requestingExtensionIds: [] };
-            providerRequests[scopesList] = {
-                disposables: [...existingRequest.disposables, menuItem, signInCommand],
-                requestingExtensionIds: [...existingRequest.requestingExtensionIds, extensionId]
-            };
-            this._signInRequestItems.set(providerId, providerRequests);
+    async getSessions(id, scopes, activateImmediate = false) {
+        const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, activateImmediate));
+        if (authProvider) {
+            return await authProvider.getSessions(scopes);
         }
         else {
-            this._signInRequestItems.set(providerId, {
-                [scopesList]: {
-                    disposables: [menuItem, signInCommand],
-                    requestingExtensionIds: [extensionId]
-                }
-            });
+            throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
-        this.updateBadgeCount();
     }
-    getLabel(id) {
-        const authProvider = this._authenticationProviders.get(id);
+    async createSession(id, scopes, options) {
+        const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, !!options?.activateImmediate));
         if (authProvider) {
-            return authProvider.label;
+            return await authProvider.createSession(scopes, {
+                sessionToRecreate: options?.sessionToRecreate
+            });
         }
         else {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
     }
-    supportsMultipleAccounts(id) {
+    async removeSession(id, sessionId) {
         const authProvider = this._authenticationProviders.get(id);
         if (authProvider) {
-            return authProvider.supportsMultipleAccounts;
+            return authProvider.removeSession(sessionId);
         }
         else {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }
     }
     async tryActivateProvider(providerId, activateImmediate) {
-        await this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(providerId), activateImmediate ? 1  : 0 );
+        await this._extensionService.activateByEvent(getAuthenticationProviderActivationEvent(providerId), activateImmediate ? 1  : 0 );
         let provider = this._authenticationProviders.get(providerId);
         if (provider) {
             return provider;
@@ -682,238 +169,9 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         }));
         return Promise.race([didRegister, didTimeout]);
     }
-    async getSessions(id, scopes, activateImmediate = false) {
-        const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, activateImmediate));
-        if (authProvider) {
-            return await authProvider.getSessions(scopes);
-        }
-        else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
-        }
-    }
-    async createSession(id, scopes, options) {
-        const authProvider = this._authenticationProviders.get(id) || (await this.tryActivateProvider(id, !!options?.activateImmediate));
-        if (authProvider) {
-            return await authProvider.createSession(scopes, {
-                sessionToRecreate: options?.sessionToRecreate
-            });
-        }
-        else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
-        }
-    }
-    async removeSession(id, sessionId) {
-        const authProvider = this._authenticationProviders.get(id);
-        if (authProvider) {
-            return authProvider.removeSession(sessionId);
-        }
-        else {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
-        }
-    }
-    readAllowedExtensions(providerId, accountName) {
-        let trustedExtensions = [];
-        try {
-            const trustedExtensionSrc = this.storageService.get(`${providerId}-${accountName}`, -1 );
-            if (trustedExtensionSrc) {
-                trustedExtensions = JSON.parse(trustedExtensionSrc);
-            }
-        }
-        catch (err) { }
-        return trustedExtensions;
-    }
-    async manageTrustedExtensionsForAccount(id, accountName) {
-        const authProvider = this._authenticationProviders.get(id);
-        if (!authProvider) {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
-        }
-        const allowedExtensions = this.readAllowedExtensions(authProvider.id, accountName);
-        const trustedExtensionAuthAccess = this.productService.trustedExtensionAuthAccess;
-        const trustedExtensionIds =
-        Array.isArray(trustedExtensionAuthAccess)
-            ? trustedExtensionAuthAccess
-            : typeof trustedExtensionAuthAccess === 'object'
-                ? trustedExtensionAuthAccess[authProvider.id] ?? []
-                : [];
-        for (const extensionId of trustedExtensionIds) {
-            const allowedExtension = allowedExtensions.find(ext => ext.id === extensionId);
-            if (!allowedExtension) {
-                const extension = await this.extensionService.getExtension(extensionId);
-                if (extension) {
-                    allowedExtensions.push({
-                        id: extensionId,
-                        name: extension.displayName || extension.name,
-                        allowed: true,
-                        trusted: true
-                    });
-                }
-            }
-            else {
-                allowedExtension.allowed = true;
-                allowedExtension.trusted = true;
-            }
-        }
-        if (!allowedExtensions.length) {
-            this.dialogService.info(( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'noTrustedExtensions',
-                "This account has not been used by any extensions."
-            )));
-            return;
-        }
-        const disposableStore = ( new DisposableStore());
-        const quickPick = disposableStore.add(this.quickInputService.createQuickPick());
-        quickPick.canSelectMany = true;
-        quickPick.customButton = true;
-        quickPick.customLabel = ( localizeWithPath(
-            'vs/workbench/services/authentication/browser/authenticationService',
-            'manageTrustedExtensions.cancel',
-            'Cancel'
-        ));
-        const usages = readAccountUsages(this.storageService, authProvider.id, accountName);
-        const trustedExtensions = [];
-        const otherExtensions = [];
-        for (const extension of allowedExtensions) {
-            const usage = usages.find(usage => extension.id === usage.extensionId);
-            extension.lastUsed = usage?.lastUsed;
-            if (extension.trusted) {
-                trustedExtensions.push(extension);
-            }
-            else {
-                otherExtensions.push(extension);
-            }
-        }
-        const sortByLastUsed = (a, b) => (b.lastUsed || 0) - (a.lastUsed || 0);
-        const toQuickPickItem = function (extension) {
-            const lastUsed = extension.lastUsed;
-            const description = lastUsed
-                ? ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                { key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] },
-                "Last used this account {0}",
-                fromNow(lastUsed, true)
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'notUsed',
-                "Has not used this account"
-            ));
-            let tooltip;
-            if (extension.trusted) {
-                tooltip = ( localizeWithPath(
-                    'vs/workbench/services/authentication/browser/authenticationService',
-                    'trustedExtensionTooltip',
-                    "This extension is trusted by Microsoft and\nalways has access to this account"
-                ));
-            }
-            return {
-                label: extension.name,
-                extension,
-                description,
-                tooltip
-            };
-        };
-        const items = [
-            ...( otherExtensions.sort(sortByLastUsed).map(toQuickPickItem)),
-            { type: 'separator', label: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'trustedExtensions',
-                "Trusted by Microsoft"
-            )) },
-            ...( trustedExtensions.sort(sortByLastUsed).map(toQuickPickItem))
-        ];
-        quickPick.items = items;
-        quickPick.selectedItems = items.filter((item) => item.type !== 'separator' && (item.extension.allowed === undefined || item.extension.allowed));
-        quickPick.title = ( localizeWithPath(
-            'vs/workbench/services/authentication/browser/authenticationService',
-            'manageTrustedExtensions',
-            "Manage Trusted Extensions"
-        ));
-        quickPick.placeholder = ( localizeWithPath(
-            'vs/workbench/services/authentication/browser/authenticationService',
-            'manageExtensions',
-            "Choose which extensions can access this account"
-        ));
-        disposableStore.add(quickPick.onDidAccept(() => {
-            const updatedAllowedList = ( quickPick.items
-                .filter((item) => item.type !== 'separator')
-                .map(i => i.extension));
-            this.storageService.store(`${authProvider.id}-${accountName}`, JSON.stringify(updatedAllowedList), -1 , 0 );
-            this._onDidChangeExtensionSessionAccess.fire({ providerId: authProvider.id, accountName });
-            quickPick.hide();
-        }));
-        disposableStore.add(quickPick.onDidChangeSelection((changed) => {
-            const trustedItems = ( new Set());
-            quickPick.items.forEach(item => {
-                const trustItem = item;
-                if (trustItem.extension) {
-                    if (trustItem.extension.trusted) {
-                        trustedItems.add(trustItem);
-                    }
-                    else {
-                        trustItem.extension.allowed = false;
-                    }
-                }
-            });
-            changed.forEach((item) => {
-                item.extension.allowed = true;
-                trustedItems.delete(item);
-            });
-            if (trustedItems.size) {
-                quickPick.selectedItems = [...changed, ...trustedItems];
-            }
-        }));
-        disposableStore.add(quickPick.onDidHide(() => {
-            disposableStore.dispose();
-        }));
-        disposableStore.add(quickPick.onDidCustom(() => {
-            quickPick.hide();
-        }));
-        quickPick.show();
-    }
-    async removeAccountSessions(id, accountName, sessions) {
-        const authProvider = this._authenticationProviders.get(id);
-        if (!authProvider) {
-            throw new Error(`No authentication provider '${id}' is currently registered.`);
-        }
-        const accountUsages = readAccountUsages(this.storageService, authProvider.id, accountName);
-        const { confirmed } = await this.dialogService.confirm({
-            type: Severity.Info,
-            message: accountUsages.length
-                ? ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'signOutMessage',
-                "The account '{0}' has been used by: \n\n{1}\n\n Sign out from these extensions?",
-                accountName,
-                ( accountUsages.map(usage => usage.extensionName)).join('\n')
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                'signOutMessageSimple',
-                "Sign out of '{0}'?",
-                accountName
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/services/authentication/browser/authenticationService',
-                { key: 'signOut', comment: ['&& denotes a mnemonic'] },
-                "&&Sign Out"
-            ))
-        });
-        if (confirmed) {
-            const removeSessionPromises = ( sessions.map(session => authProvider.removeSession(session.id)));
-            await Promise.all(removeSessionPromises);
-            removeAccountUsage(this.storageService, authProvider.id, accountName);
-            this.storageService.remove(`${authProvider.id}-${accountName}`, -1 );
-        }
-    }
 };
 AuthenticationService = ( __decorate([
-    ( __param(0, IActivityService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IDialogService)),
-    ( __param(4, IQuickInputService)),
-    ( __param(5, IProductService)),
-    ( __param(6, IBrowserWorkbenchEnvironmentService))
+    ( __param(0, IExtensionService)),
+    ( __param(1, IAuthenticationAccessService))
 ], AuthenticationService));
-export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo };
+export { AuthenticationService, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo };