@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/aiRelatedInformation/common/aiRelatedInformationService.js

@@ -0,0 +1,82 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { raceTimeout, createCancelablePromise } from '../../../../base/common/async.js';
+import { StopWatch } from '../../../../base/common/stopwatch.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import './aiRelatedInformation.js';
+var AiRelatedInformationService_1;
+let AiRelatedInformationService = class AiRelatedInformationService {
+    static { AiRelatedInformationService_1 = this; }
+    static { this.DEFAULT_TIMEOUT = 1000 * 10; }
+    constructor(logService) {
+        this.logService = logService;
+        this._providers = ( new Map());
+    }
+    isEnabled() {
+        return this._providers.size > 0;
+    }
+    registerAiRelatedInformationProvider(type, provider) {
+        const providers = this._providers.get(type) ?? [];
+        providers.push(provider);
+        this._providers.set(type, providers);
+        return {
+            dispose: () => {
+                const providers = this._providers.get(type) ?? [];
+                const index = providers.indexOf(provider);
+                if (index !== -1) {
+                    providers.splice(index, 1);
+                }
+                if (providers.length === 0) {
+                    this._providers.delete(type);
+                }
+            }
+        };
+    }
+    async getRelatedInformation(query, types, token) {
+        if (this._providers.size === 0) {
+            throw new Error('No related information providers registered');
+        }
+        const providers = [];
+        for (const type of types) {
+            const typeProviders = this._providers.get(type);
+            if (typeProviders) {
+                providers.push(...typeProviders);
+            }
+        }
+        if (providers.length === 0) {
+            throw new Error('No related information providers registered for the given types');
+        }
+        const stopwatch = StopWatch.create();
+        const cancellablePromises = ( providers.map((provider) => {
+            return createCancelablePromise(async (t) => {
+                try {
+                    const result = await provider.provideAiRelatedInformation(query, t);
+                    return result.filter(r => types.includes(r.type));
+                }
+                catch (e) {
+                }
+                return [];
+            });
+        }));
+        try {
+            const results = await raceTimeout(Promise.allSettled(cancellablePromises), AiRelatedInformationService_1.DEFAULT_TIMEOUT, () => {
+                cancellablePromises.forEach(p => p.cancel());
+                this.logService.warn('[AiRelatedInformationService]: Related information provider timed out');
+            });
+            if (!results) {
+                return [];
+            }
+            const result = results
+                .filter(r => r.status === 'fulfilled')
+                .flatMap(r => r.value);
+            return result;
+        }
+        finally {
+            stopwatch.stop();
+            this.logService.trace(`[AiRelatedInformationService]: getRelatedInformation took ${stopwatch.elapsed()}ms`);
+        }
+    }
+};
+AiRelatedInformationService = AiRelatedInformationService_1 = ( __decorate([
+    ( __param(0, ILogService))
+], AiRelatedInformationService));
+export { AiRelatedInformationService };

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

@@ -0,0 +1,369 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable, dispose } from '../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { Severity } from '../../../../platform/notification/common/notification.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IActivityService, NumberBadge } from '../../activity/common/activity.js';
+import { IAuthenticationAccessService } from './authenticationAccessService.js';
+import { IAuthenticationUsageService } from './authenticationUsageService.js';
+import { IAuthenticationService } from '../common/authentication.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+const SCOPESLIST_SEPARATOR = ' ';
+let AuthenticationExtensionsService = class AuthenticationExtensionsService extends Disposable {
+    constructor(activityService, storageService, dialogService, quickInputService, _authenticationService, _authenticationUsageService, _authenticationAccessService) {
+        super();
+        this.activityService = activityService;
+        this.storageService = storageService;
+        this.dialogService = dialogService;
+        this.quickInputService = quickInputService;
+        this._authenticationService = _authenticationService;
+        this._authenticationUsageService = _authenticationUsageService;
+        this._authenticationAccessService = _authenticationAccessService;
+        this._signInRequestItems = ( new Map());
+        this._sessionAccessRequestItems = ( new Map());
+        this._accountBadgeDisposable = this._register(( new MutableDisposable()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this._authenticationService.onDidChangeSessions(async (e) => {
+            if (e.event.added?.length) {
+                await this.updateNewSessionRequests(e.providerId, e.event.added);
+            }
+            if (e.event.removed?.length) {
+                await this.updateAccessRequests(e.providerId, e.event.removed);
+            }
+            this.updateBadgeCount();
+        }));
+        this._register(this._authenticationService.onDidUnregisterAuthenticationProvider(e => {
+            const accessRequests = this._sessionAccessRequestItems.get(e.id) || {};
+            ( Object.keys(accessRequests)).forEach(extensionId => {
+                this.removeAccessRequest(e.id, extensionId);
+            });
+        }));
+    }
+    async updateNewSessionRequests(providerId, addedSessions) {
+        const existingRequestsForProvider = this._signInRequestItems.get(providerId);
+        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(providerId);
+                }
+                else {
+                    this._signInRequestItems.set(providerId, 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/authenticationExtensionsService',
+                '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();
+        }
+    }
+    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(provider, accountName, extensionId, extensionName) {
+        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/authenticationExtensionsService',
+                'confirmAuthenticationAccess',
+                "The extension '{0}' wants to access the {1} account '{2}'.",
+                extensionName,
+                provider.label,
+                accountName
+            )),
+            buttons: [
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/authentication/browser/authenticationExtensionsService',
+                        { key: 'allow', comment: ['&& denotes a mnemonic'] },
+                        "&&Allow"
+                    )),
+                    run: () => SessionPromptChoice.Allow
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/authentication/browser/authenticationExtensionsService',
+                        { key: 'deny', comment: ['&& denotes a mnemonic'] },
+                        "&&Deny"
+                    )),
+                    run: () => SessionPromptChoice.Deny
+                }
+            ],
+            cancelButton: {
+                run: () => SessionPromptChoice.Cancel
+            }
+        });
+        if (result !== SessionPromptChoice.Cancel) {
+            this._authenticationAccessService.updateAllowedExtensions(provider.id, accountName, [{ id: extensionId, name: extensionName, allowed: result === SessionPromptChoice.Allow }]);
+            this.removeAccessRequest(provider.id, extensionId);
+        }
+        return result === SessionPromptChoice.Allow;
+    }
+    async selectSession(providerId, extensionId, extensionName, scopes, availableSessions) {
+        return ( new Promise((resolve, reject) => {
+            if (!availableSessions.length) {
+                reject('No available sessions');
+                return;
+            }
+            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/authenticationExtensionsService',
+                    'useOtherAccount',
+                    "Sign in to another account"
+                ))
+            });
+            quickPick.items = items;
+            quickPick.title = ( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
+                {
+                    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,
+                this._authenticationService.getProvider(providerId).label
+            ));
+            quickPick.placeholder = ( localizeWithPath(
+                'vs/workbench/services/authentication/browser/authenticationExtensionsService',
+                'getSessionPlateholder',
+                "Select an account for '{0}' to use or Esc to cancel",
+                extensionName
+            ));
+            quickPick.onDidAccept(async (_) => {
+                const session = quickPick.selectedItems[0].session ?? (await this._authenticationService.createSession(providerId, scopes));
+                const accountName = session.account.label;
+                this._authenticationAccessService.updateAllowedExtensions(providerId, accountName, [{ id: extensionId, name: extensionName, allowed: 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(provider, extensionId, extensionName, scopes) {
+        const providerRequests = this._sessionAccessRequestItems.get(provider.id) || {};
+        const existingRequest = providerRequests[extensionId];
+        if (!existingRequest) {
+            return;
+        }
+        if (!provider) {
+            return;
+        }
+        const possibleSessions = existingRequest.possibleSessions;
+        let session;
+        if (provider.supportsMultipleAccounts) {
+            try {
+                session = await this.selectSession(provider.id, extensionId, extensionName, scopes, possibleSessions);
+            }
+            catch (_) {
+            }
+        }
+        else {
+            const approved = await this.showGetSessionPrompt(provider, possibleSessions[0].account.label, extensionId, extensionName);
+            if (approved) {
+                session = possibleSessions[0];
+            }
+        }
+        if (session) {
+            this._authenticationUsageService.addAccountUsage(provider.id, session.account.label, extensionId, extensionName);
+        }
+    }
+    requestSessionAccess(providerId, extensionId, extensionName, scopes, possibleSessions) {
+        const providerRequests = this._sessionAccessRequestItems.get(providerId) || {};
+        const hasExistingRequest = providerRequests[extensionId];
+        if (hasExistingRequest) {
+            return;
+        }
+        const provider = this._authenticationService.getProvider(providerId);
+        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+            group: '3_accessRequests',
+            command: {
+                id: `${providerId}${extensionId}Access`,
+                title: ( localizeWithPath(
+                    'vs/workbench/services/authentication/browser/authenticationExtensionsService',
+                    {
+                        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)",
+                    provider.label,
+                    extensionName
+                ))
+            }
+        }));
+        const accessCommand = CommandsRegistry.registerCommand({
+            id: `${providerId}${extensionId}Access`,
+            handler: async (accessor) => {
+                this.completeSessionAccessRequest(provider, extensionId, extensionName, scopes);
+            }
+        });
+        providerRequests[extensionId] = { possibleSessions, disposables: [menuItem, accessCommand] };
+        this._sessionAccessRequestItems.set(providerId, providerRequests);
+        this.updateBadgeCount();
+    }
+    async requestNewSession(providerId, scopes, extensionId, extensionName) {
+        if (!this._authenticationService.isAuthenticationProviderRegistered(providerId)) {
+            await ( new Promise((resolve, _) => {
+                const dispose = this._authenticationService.onDidRegisterAuthenticationProvider(e => {
+                    if (e.id === providerId) {
+                        dispose.dispose();
+                        resolve();
+                    }
+                });
+            }));
+        }
+        let provider;
+        try {
+            provider = this._authenticationService.getProvider(providerId);
+        }
+        catch (_e) {
+            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/authenticationExtensionsService',
+                    {
+                        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._authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: 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);
+        }
+        else {
+            this._signInRequestItems.set(providerId, {
+                [scopesList]: {
+                    disposables: [menuItem, signInCommand],
+                    requestingExtensionIds: [extensionId]
+                }
+            });
+        }
+        this.updateBadgeCount();
+    }
+};
+AuthenticationExtensionsService = ( __decorate([
+    ( __param(0, IActivityService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IAuthenticationService)),
+    ( __param(5, IAuthenticationUsageService)),
+    ( __param(6, IAuthenticationAccessService))
+], AuthenticationExtensionsService));
+export { AuthenticationExtensionsService };

package/vscode/src/vs/workbench/services/commands/common/commandService.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { timeout } from '../../../../base/common/async.js';
+let CommandService = class CommandService extends Disposable {
+    constructor(_instantiationService, _extensionService, _logService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._extensionService = _extensionService;
+        this._logService = _logService;
+        this._extensionHostIsReady = false;
+        this._onWillExecuteCommand = this._register(( new Emitter()));
+        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+        this._onDidExecuteCommand = ( new Emitter());
+        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+        this._extensionService.whenInstalledExtensionsRegistered().then(value => this._extensionHostIsReady = value);
+        this._starActivation = null;
+    }
+    _activateStar() {
+        if (!this._starActivation) {
+            this._starActivation = Promise.race([
+                this._extensionService.activateByEvent(`*`),
+                timeout(30000)
+            ]);
+        }
+        return this._starActivation;
+    }
+    async executeCommand(id, ...args) {
+        this._logService.trace('CommandService#executeCommand', id);
+        const activationEvent = `onCommand:${id}`;
+        const commandIsRegistered = !!CommandsRegistry.getCommand(id);
+        if (commandIsRegistered) {
+            if (this._extensionService.activationEventIsDone(activationEvent)) {
+                return this._tryExecuteCommand(id, args);
+            }
+            if (!this._extensionHostIsReady) {
+                this._extensionService.activateByEvent(activationEvent);
+                return this._tryExecuteCommand(id, args);
+            }
+            await this._extensionService.activateByEvent(activationEvent);
+            return this._tryExecuteCommand(id, args);
+        }
+        await Promise.all([
+            this._extensionService.activateByEvent(activationEvent),
+            Promise.race([
+                this._activateStar(),
+                Event.toPromise(Event.filter(CommandsRegistry.onDidRegisterCommand, e => e === id))
+            ]),
+        ]);
+        return this._tryExecuteCommand(id, args);
+    }
+    _tryExecuteCommand(id, args) {
+        const command = CommandsRegistry.getCommand(id);
+        if (!command) {
+            return Promise.reject(( new Error(`command '${id}' not found`)));
+        }
+        try {
+            this._onWillExecuteCommand.fire({ commandId: id, args });
+            const result = this._instantiationService.invokeFunction(command.handler, ...args);
+            this._onDidExecuteCommand.fire({ commandId: id, args });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+};
+CommandService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, ILogService))
+], CommandService));
+export { CommandService };