@codingame/monaco-vscode-authentication-service-override 9.0.3 → 10.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-authentication-service-override",
-  "version": "9.0.3",
+  "version": "10.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@9.0.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@10.0.0"
   }
 }

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

@@ -1,9 +1,7 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
-import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
@@ -37,7 +35,7 @@ let AuthenticationAccessService = class AuthenticationAccessService extends Disp
     readAllowedExtensions(providerId, accountName) {
         let trustedExtensions = [];
         try {
-            const trustedExtensionSrc = this._storageService.get(`${providerId}-${accountName}`, StorageScope.APPLICATION);
+            const trustedExtensionSrc = this._storageService.get(`${providerId}-${accountName}`, -1 );
             if (trustedExtensionSrc) {
                 trustedExtensions = JSON.parse(trustedExtensionSrc);
             }
@@ -56,11 +54,11 @@ let AuthenticationAccessService = class AuthenticationAccessService extends Disp
                 allowList[index].allowed = extension.allowed;
             }
         }
-        this._storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), StorageScope.APPLICATION, StorageTarget.USER);
+        this._storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), -1 , 0 );
         this._onDidChangeExtensionSessionAccess.fire({ providerId, accountName });
     }
     removeAllowedExtensions(providerId, accountName) {
-        this._storageService.remove(`${providerId}-${accountName}`, StorageScope.APPLICATION);
+        this._storageService.remove(`${providerId}-${accountName}`, -1 );
         this._onDidChangeExtensionSessionAccess.fire({ providerId, accountName });
     }
 };

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

@@ -4,32 +4,42 @@ import { localize } from 'vscode/vscode/vs/nls';
 import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import 'vscode/vscode/vs/platform/notification/common/notification';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
-import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
 import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
 import { IAuthenticationAccessService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationAccessService.service';
 import { IAuthenticationUsageService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationUsageService.service';
 import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 const SCOPESLIST_SEPARATOR = ' ';
 let AuthenticationExtensionsService = class AuthenticationExtensionsService extends Disposable {
-    constructor(activityService, storageService, dialogService, quickInputService, _authenticationService, _authenticationUsageService, _authenticationAccessService) {
+    constructor(activityService, storageService, dialogService, quickInputService, _productService, _authenticationService, _authenticationUsageService, _authenticationAccessService) {
         super();
         this.activityService = activityService;
         this.storageService = storageService;
         this.dialogService = dialogService;
         this.quickInputService = quickInputService;
+        this._productService = _productService;
         this._authenticationService = _authenticationService;
         this._authenticationUsageService = _authenticationUsageService;
         this._authenticationAccessService = _authenticationAccessService;
         this._signInRequestItems = ( (new Map()));
         this._sessionAccessRequestItems = ( (new Map()));
         this._accountBadgeDisposable = this._register(( (new MutableDisposable())));
+        this._onDidAccountPreferenceChange = this._register(( (new Emitter())));
+        this.onDidChangeAccountPreference = this._onDidAccountPreferenceChange.event;
+        this._inheritAuthAccountPreferenceParentToChildren = this._productService.inheritAuthAccountPreference || {};
+        this._inheritAuthAccountPreferenceChildToParent = Object.entries(this._inheritAuthAccountPreferenceParentToChildren).reduce((acc, [parent, children]) => {
+            children.forEach((child) => {
+                acc[child] = parent;
+            });
+            return acc;
+        }, {});
         this.registerListeners();
     }
     registerListeners() {
@@ -98,7 +108,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
             numberOfRequests += ( (Object.keys(accessRequest))).length;
         });
         if (numberOfRequests > 0) {
-            const badge = ( (new NumberBadge(numberOfRequests, () => ( localize(2247, "Sign in requested")))));
+            const badge = ( (new NumberBadge(numberOfRequests, () => ( localize(2160, "Sign in requested")))));
             this._accountBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
         }
     }
@@ -110,19 +120,44 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
             this.updateBadgeCount();
         }
     }
+    updateAccountPreference(extensionId, providerId, account) {
+        const parentExtensionId = this._inheritAuthAccountPreferenceChildToParent[extensionId] ?? extensionId;
+        const key = this._getKey(parentExtensionId, providerId);
+        this.storageService.store(key, account.label, 1 , 1 );
+        this.storageService.store(key, account.label, -1 , 1 );
+        const childrenExtensions = this._inheritAuthAccountPreferenceParentToChildren[parentExtensionId];
+        const extensionIds = childrenExtensions ? [parentExtensionId, ...childrenExtensions] : [parentExtensionId];
+        this._onDidAccountPreferenceChange.fire({ extensionIds, providerId });
+    }
+    getAccountPreference(extensionId, providerId) {
+        const key = this._getKey(this._inheritAuthAccountPreferenceChildToParent[extensionId] ?? extensionId, providerId);
+        return this.storageService.get(key, 1 ) ?? this.storageService.get(key, -1 );
+    }
+    removeAccountPreference(extensionId, providerId) {
+        const key = this._getKey(this._inheritAuthAccountPreferenceChildToParent[extensionId] ?? extensionId, providerId);
+        this.storageService.remove(key, 1 );
+        this.storageService.remove(key, -1 );
+    }
+    _getKey(extensionId, providerId) {
+        return `${extensionId}-${providerId}`;
+    }
     updateSessionPreference(providerId, extensionId, session) {
         const key = `${extensionId}-${providerId}-${session.scopes.join(SCOPESLIST_SEPARATOR)}`;
-        this.storageService.store(key, session.id, StorageScope.WORKSPACE, StorageTarget.MACHINE);
-        this.storageService.store(key, session.id, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        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(SCOPESLIST_SEPARATOR)}`;
-        return this.storageService.get(key, StorageScope.WORKSPACE) ?? this.storageService.get(key, StorageScope.APPLICATION);
+        return this.storageService.get(key, 1 ) ?? this.storageService.get(key, -1 );
     }
     removeSessionPreference(providerId, extensionId, scopes) {
         const key = `${extensionId}-${providerId}-${scopes.join(SCOPESLIST_SEPARATOR)}`;
-        this.storageService.remove(key, StorageScope.WORKSPACE);
-        this.storageService.remove(key, StorageScope.APPLICATION);
+        this.storageService.remove(key, 1 );
+        this.storageService.remove(key, -1 );
+    }
+    _updateAccountAndSessionPreferences(providerId, extensionId, session) {
+        this.updateAccountPreference(extensionId, providerId, session.account);
+        this.updateSessionPreference(providerId, extensionId, session);
     }
     async showGetSessionPrompt(provider, accountName, extensionId, extensionName) {
         let SessionPromptChoice;
@@ -134,7 +169,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
         const { result } = await this.dialogService.prompt({
             type: Severity$1.Info,
             message: ( localize(
-                2248,
+                2161,
                 "The extension '{0}' wants to access the {1} account '{2}'.",
                 extensionName,
                 provider.label,
@@ -142,11 +177,11 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
             )),
             buttons: [
                 {
-                    label: ( localize(2249, "&&Allow")),
+                    label: ( localize(2162, "&&Allow")),
                     run: () => SessionPromptChoice.Allow
                 },
                 {
-                    label: ( localize(2250, "&&Deny")),
+                    label: ( localize(2163, "&&Deny")),
                     run: () => SessionPromptChoice.Deny
                 }
             ],
@@ -168,27 +203,29 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
         const disposables = ( (new DisposableStore()));
         const quickPick = disposables.add(this.quickInputService.createQuickPick());
         quickPick.ignoreFocusOut = true;
-        const items = ( (availableSessions.map(session => {
+        const accountsWithSessions = ( (new Set()));
+        const items = ( (availableSessions
+            .filter(session => !( (accountsWithSessions.has(session.account.label))) && accountsWithSessions.add(session.account.label))
+            .map(session => {
             return {
                 label: session.account.label,
                 session: session
             };
         })));
-        const accountsWithSessions = ( (new Set( (availableSessions.map(session => session.account.label)))));
         allAccounts.forEach(account => {
             if (!( (accountsWithSessions.has(account.label)))) {
                 items.push({ label: account.label, account });
             }
         });
-        items.push({ label: ( localize(2251, "Sign in to another account")) });
+        items.push({ label: ( localize(2164, "Sign in to another account")) });
         quickPick.items = items;
         quickPick.title = ( localize(
-            2252,
+            2165,
             "The extension '{0}' wants to access a {1} account",
             extensionName,
             this._authenticationService.getProvider(providerId).label
         ));
-        quickPick.placeholder = ( localize(2253, "Select an account for '{0}' to use or Esc to cancel", extensionName));
+        quickPick.placeholder = ( localize(2166, "Select an account for '{0}' to use or Esc to cancel", extensionName));
         return await ( (new Promise((resolve, reject) => {
             disposables.add(quickPick.onDidAccept(async (_) => {
                 quickPick.dispose();
@@ -205,7 +242,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
                 }
                 const accountName = session.account.label;
                 this._authenticationAccessService.updateAllowedExtensions(providerId, accountName, [{ id: extensionId, name: extensionName, allowed: true }]);
-                this.updateSessionPreference(providerId, extensionId, session);
+                this._updateAccountAndSessionPreferences(providerId, extensionId, session);
                 this.removeAccessRequest(providerId, extensionId);
                 resolve(session);
             }));
@@ -257,7 +294,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
             group: '3_accessRequests',
             command: {
                 id: `${providerId}${extensionId}Access`,
-                title: ( localize(2254, "Grant access to {0} for {1}... (1)", provider.label, extensionName))
+                title: ( localize(2167, "Grant access to {0} for {1}... (1)", provider.label, extensionName))
             }
         })));
         const accessCommand = CommandsRegistry.registerCommand({
@@ -301,7 +338,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
             group: '2_signInRequests',
             command: {
                 id: commandId,
-                title: ( localize(2255, "Sign in with {0} to use {1} (1)", provider.label, extensionName))
+                title: ( localize(2168, "Sign in with {0} to use {1} (1)", provider.label, extensionName))
             }
         })));
         const signInCommand = CommandsRegistry.registerCommand({
@@ -310,7 +347,7 @@ let AuthenticationExtensionsService = class AuthenticationExtensionsService exte
                 const authenticationService = accessor.get(IAuthenticationService);
                 const session = await authenticationService.createSession(providerId, scopes);
                 this._authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: true }]);
-                this.updateSessionPreference(providerId, extensionId, session);
+                this._updateAccountAndSessionPreferences(providerId, extensionId, session);
             }
         });
         if (providerRequests) {
@@ -337,9 +374,10 @@ AuthenticationExtensionsService = ( (__decorate([
     ( (__param(1, IStorageService))),
     ( (__param(2, IDialogService))),
     ( (__param(3, IQuickInputService))),
-    ( (__param(4, IAuthenticationService))),
-    ( (__param(5, IAuthenticationUsageService))),
-    ( (__param(6, IAuthenticationAccessService)))
+    ( (__param(4, IProductService))),
+    ( (__param(5, IAuthenticationService))),
+    ( (__param(6, IAuthenticationUsageService))),
+    ( (__param(7, IAuthenticationAccessService)))
 ], AuthenticationExtensionsService)));
 
 export { AuthenticationExtensionsService };

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

@@ -1,16 +1,45 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
-import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { Queue } from 'vscode/vscode/vs/base/common/async';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication.service';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
-let AuthenticationUsageService = class AuthenticationUsageService {
-    constructor(_storageService) {
+let AuthenticationUsageService = class AuthenticationUsageService extends Disposable {
+    constructor(_storageService, _authenticationService, _logService, productService) {
+        super();
         this._storageService = _storageService;
+        this._authenticationService = _authenticationService;
+        this._logService = _logService;
+        this._queue = ( new Queue());
+        this._extensionsUsingAuth = ( new Set());
+        const trustedExtensionAuthAccess = productService.trustedExtensionAuthAccess;
+        if (Array.isArray(trustedExtensionAuthAccess)) {
+            for (const extensionId of trustedExtensionAuthAccess) {
+                this._extensionsUsingAuth.add(extensionId);
+            }
+        }
+        else if (trustedExtensionAuthAccess) {
+            for (const extensions of ( Object.values(trustedExtensionAuthAccess))) {
+                for (const extensionId of extensions) {
+                    this._extensionsUsingAuth.add(extensionId);
+                }
+            }
+        }
+        this._authenticationService.onDidRegisterAuthenticationProvider(provider => this._queue.queue(() => this._addExtensionsToCache(provider.id)));
+    }
+    async initializeExtensionUsageCache() {
+        await this._queue.queue(() => Promise.all(( this._authenticationService.getProviderIds().map(providerId => this._addExtensionsToCache(providerId)))));
+    }
+    async extensionUsesAuth(extensionId) {
+        await this._queue.whenIdle();
+        return ( this._extensionsUsingAuth.has(extensionId));
     }
     readAccountUsages(providerId, accountName) {
         const accountKey = `${providerId}-${accountName}-usages`;
-        const storedUsages = this._storageService.get(accountKey, StorageScope.APPLICATION);
+        const storedUsages = this._storageService.get(accountKey, -1 );
         let usages = [];
         if (storedUsages) {
             try {
@@ -23,7 +52,7 @@ let AuthenticationUsageService = class AuthenticationUsageService {
     }
     removeAccountUsage(providerId, accountName) {
         const accountKey = `${providerId}-${accountName}-usages`;
-        this._storageService.remove(accountKey, StorageScope.APPLICATION);
+        this._storageService.remove(accountKey, -1 );
     }
     addAccountUsage(providerId, accountName, extensionId, extensionName) {
         const accountKey = `${providerId}-${accountName}-usages`;
@@ -43,11 +72,29 @@ let AuthenticationUsageService = class AuthenticationUsageService {
                 lastUsed: Date.now()
             });
         }
-        this._storageService.store(accountKey, JSON.stringify(usages), StorageScope.APPLICATION, StorageTarget.MACHINE);
+        this._storageService.store(accountKey, JSON.stringify(usages), -1 , 1 );
+        this._extensionsUsingAuth.add(extensionId);
+    }
+    async _addExtensionsToCache(providerId) {
+        try {
+            const accounts = await this._authenticationService.getAccounts(providerId);
+            for (const account of accounts) {
+                const usage = this.readAccountUsages(providerId, account.label);
+                for (const u of usage) {
+                    this._extensionsUsingAuth.add(u.extensionId);
+                }
+            }
+        }
+        catch (e) {
+            this._logService.error(e);
+        }
     }
 };
 AuthenticationUsageService = ( __decorate([
-    ( __param(0, IStorageService))
+    ( __param(0, IStorageService)),
+    ( __param(1, IAuthenticationService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IProductService))
 ], AuthenticationUsageService));
 
 export { AuthenticationUsageService };