@codingame/monaco-vscode-api 1.82.6 → 1.83.0-next.0

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

@@ -2,14 +2,13 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ICommentService } from '../../contrib/comments/browser/commentService.js';
 import { CommentsPanel } from '../../contrib/comments/browser/commentsView.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from '../../contrib/comments/browser/commentsTreeViewer.js';
+import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_ORIGINAL_TITLE, COMMENTS_VIEW_STORAGE_ID } from '../../contrib/comments/browser/commentsTreeViewer.js';
 import { Extensions, IViewsService, IViewDescriptorService } from '../../common/views.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { ViewPaneContainer } from '../../browser/parts/views/viewPaneContainer.js';
@@ -214,14 +213,16 @@ class MainThreadCommentController {
             this._commentService.updateComments(this._uniqueId, {
                 added: [thread],
                 removed: [],
-                changed: []
+                changed: [],
+                pending: []
             });
         }
         else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [thread],
                 removed: [],
-                changed: []
+                changed: [],
+                pending: []
             });
         }
         return thread;
@@ -233,14 +234,16 @@ class MainThreadCommentController {
             this._commentService.updateComments(this._uniqueId, {
                 added: [],
                 removed: [],
-                changed: [thread]
+                changed: [thread],
+                pending: []
             });
         }
         else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [],
                 removed: [],
-                changed: [thread]
+                changed: [thread],
+                pending: []
             });
         }
     }
@@ -252,14 +255,16 @@ class MainThreadCommentController {
             this._commentService.updateComments(this._uniqueId, {
                 added: [],
                 removed: [thread],
-                changed: []
+                changed: [],
+                pending: []
             });
         }
         else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [],
                 removed: [thread],
-                changed: []
+                changed: [],
+                pending: []
             });
         }
     }
@@ -388,8 +393,8 @@ let MainThreadComments = class MainThreadComments extends Disposable {
             controller.activeCommentThread = this._activeCommentThread;
         }));
     }
-    $registerCommentController(handle, id, label) {
-        const providerId = generateUuid();
+    $registerCommentController(handle, id, label, extensionId) {
+        const providerId = `${label}-${extensionId}`;
         this._handlers.set(handle, providerId);
         const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
         this._commentService.registerCommentController(providerId, provider);
@@ -451,7 +456,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         if (!commentsViewAlreadyRegistered) {
             const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
-                title: COMMENTS_VIEW_TITLE,
+                title: { value: COMMENTS_VIEW_TITLE, original: COMMENTS_VIEW_ORIGINAL_TITLE },
                 ctorDescriptor: ( new SyncDescriptor(
                     ViewPaneContainer,
                     [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, toDisposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IDebugService } from '../../contrib/debug/common/debug.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
@@ -14,18 +14,32 @@ let MainThreadDebugService = class MainThreadDebugService {
         this._toDispose = ( new DisposableStore());
         this._debugAdaptersHandleCounter = 1;
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
+        const sessionListeners = ( new DisposableMap());
+        this._toDispose.add(sessionListeners);
         this._toDispose.add(debugService.onDidNewSession(session => {
             this._proxy.$acceptDebugSessionStarted(this.getSessionDto(session));
-            this._toDispose.add(session.onDidChangeName(name => {
+            const store = sessionListeners.get(session);
+            store.add(session.onDidChangeName(name => {
                 this._proxy.$acceptDebugSessionNameChanged(this.getSessionDto(session), name);
             }));
         }));
         this._toDispose.add(debugService.onWillNewSession(session => {
-            this._toDispose.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
+            let store = sessionListeners.get(session);
+            if (!store) {
+                store = ( new DisposableStore());
+                sessionListeners.set(session, store);
+            }
+            store.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
         }));
         this._toDispose.add(debugService.onDidEndSession(session => {
             this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
             this._sessions.delete(session.getId());
+            for (const [handle, value] of this._debugAdapters) {
+                if (value.session === session) {
+                    this._debugAdapters.delete(handle);
+                }
+            }
+            sessionListeners.deleteAndDispose(session);
         }));
         this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
             this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
@@ -344,12 +358,12 @@ MainThreadDebugService = __decorate([
     ( __param(1, IDebugService))
 ], MainThreadDebugService);
 class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
-    constructor(_ds, _handle, _proxy, _session) {
+    constructor(_ds, _handle, _proxy, session) {
         super();
         this._ds = _ds;
         this._handle = _handle;
         this._proxy = _proxy;
-        this._session = _session;
+        this.session = session;
     }
     fireError(handle, err) {
         this._onError.fire(err);
@@ -358,7 +372,7 @@ class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
         this._onExit.fire(code);
     }
     startSession() {
-        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this._session)));
+        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this.session)));
     }
     sendMessage(message) {
         this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));

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

@@ -41,8 +41,8 @@ class MainThreadTextEditorProperties {
         let lineNumbers;
         if (codeEditor) {
             const options = codeEditor.getOptions();
-            const lineNumbersOpts = options.get(66 );
-            cursorStyle = options.get(27 );
+            const lineNumbersOpts = options.get(67 );
+            cursorStyle = options.get(28 );
             lineNumbers = lineNumbersOpts.renderType;
         }
         else if (previousProperties) {

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

@@ -407,7 +407,7 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
             if (viewColumn === SIDE_GROUP) {
                 direction = preferredSideBySideGroupDirection(this._configurationService);
             }
-            targetGroup = this._editorGroupsService.addGroup(this._editorGroupsService.groups[this._editorGroupsService.groups.length - 1], direction, undefined);
+            targetGroup = this._editorGroupsService.addGroup(this._editorGroupsService.groups[this._editorGroupsService.groups.length - 1], direction);
         }
         else {
             targetGroup = this._editorGroupsService.getGroup(groupId);

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { disposed } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { illegalArgument } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
@@ -121,7 +121,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     $trySetSelections(id, selections) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         editor.setSelections(selections);
         return Promise.resolve(undefined);
@@ -130,7 +130,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         key = `${this._instanceId}-${key}`;
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         editor.setDecorations(key, ranges);
         return Promise.resolve(undefined);
@@ -139,7 +139,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         key = `${this._instanceId}-${key}`;
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         editor.setDecorationsFast(key, ranges);
         return Promise.resolve(undefined);
@@ -147,7 +147,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     $tryRevealRange(id, range, revealType) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         editor.revealRange(range, revealType);
         return Promise.resolve();
@@ -155,7 +155,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     $trySetOptions(id, options) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         editor.setConfiguration(options);
         return Promise.resolve(undefined);
@@ -163,14 +163,14 @@ let MainThreadTextEditors = class MainThreadTextEditors {
     $tryApplyEdits(id, modelVersionId, edits, opts) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         return Promise.resolve(editor.applyEdits(modelVersionId, edits, opts));
     }
     $tryInsertSnippet(id, modelVersionId, template, ranges, opts) {
         const editor = this._editorLocator.getEditor(id);
         if (!editor) {
-            return Promise.reject(disposed(`TextEditor(${id})`));
+            return Promise.reject(illegalArgument(`TextEditor(${id})`));
         }
         return Promise.resolve(editor.insertSnippet(modelVersionId, template, ranges, opts));
     }

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

@@ -168,9 +168,10 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 severity: Severity.Error,
                 message: ( localize(
                     'uninstalledDep',
-                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not installed. Would you like to install the extension and reload the window?",
+                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
-                    dependencyExtension.displayName
+                    dependencyExtension.displayName,
+                    dependencyExtension.publisherDisplayName
                 )),
                 actions: {
                     primary: [( new Action('install', ( localize('install missing dep', "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)

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

@@ -9,6 +9,21 @@ import { Sequence } from 'monaco-editor/esm/vs/base/common/sequence.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { IQuickDiffService } from '../../contrib/scm/common/quickDiff.js';
+function getSCMHistoryItemIcon(historyItem) {
+    if (!historyItem.icon) {
+        return undefined;
+    }
+    else if (URI.isUri(historyItem.icon)) {
+        return URI.revive(historyItem.icon);
+    }
+    else if (ThemeIcon.isThemeIcon(historyItem.icon)) {
+        return historyItem.icon;
+    }
+    else {
+        const icon = historyItem.icon;
+        return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
+    }
+}
 class MainThreadSCMResourceGroup {
     get hideWhenEmpty() { return !!this.features.hideWhenEmpty; }
     constructor(sourceControlHandle, handle, provider, features, label, id) {
@@ -68,6 +83,45 @@ class MainThreadSCMResource {
         };
     }
 }
+class MainThreadSCMHistoryProvider {
+    get actionButton() { return this._actionButton; }
+    set actionButton(actionButton) {
+        this._actionButton = actionButton;
+        this._onDidChangeActionButton.fire();
+    }
+    get currentHistoryItemGroup() { return this._currentHistoryItemGroup; }
+    set currentHistoryItemGroup(historyItemGroup) {
+        this._currentHistoryItemGroup = historyItemGroup;
+        this._onDidChangeCurrentHistoryItemGroup.fire();
+    }
+    constructor(proxy, handle) {
+        this.proxy = proxy;
+        this.handle = handle;
+        this._onDidChangeActionButton = ( new Emitter());
+        this.onDidChangeActionButton = this._onDidChangeActionButton.event;
+        this._onDidChangeCurrentHistoryItemGroup = ( new Emitter());
+        this.onDidChangeCurrentHistoryItemGroup = this._onDidChangeCurrentHistoryItemGroup.event;
+    }
+    async resolveHistoryItemGroupBase(historyItemGroupId) {
+        return this.proxy.$resolveHistoryItemGroupBase(this.handle, historyItemGroupId, CancellationToken.None);
+    }
+    async resolveHistoryItemGroupCommonAncestor(historyItemGroupId1, historyItemGroupId2) {
+        return this.proxy.$resolveHistoryItemGroupCommonAncestor(this.handle, historyItemGroupId1, historyItemGroupId2, CancellationToken.None);
+    }
+    async provideHistoryItems(historyItemGroupId, options) {
+        const historyItems = await this.proxy.$provideHistoryItems(this.handle, historyItemGroupId, options, CancellationToken.None);
+        return historyItems?.map(historyItem => ({ ...historyItem, icon: getSCMHistoryItemIcon(historyItem), }));
+    }
+    async provideHistoryItemChanges(historyItemId) {
+        const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, CancellationToken.None);
+        return changes?.map(change => ({
+            uri: URI.revive(change.uri),
+            originalUri: change.originalUri && URI.revive(change.originalUri),
+            modifiedUri: change.modifiedUri && URI.revive(change.modifiedUri),
+            renameUri: change.renameUri && URI.revive(change.renameUri)
+        }));
+    }
+}
 class MainThreadSCMProvider {
     static { this.ID_HANDLE = 0; }
     get id() { return this._id; }
@@ -77,6 +131,7 @@ class MainThreadSCMProvider {
     get inputBoxDocumentUri() { return this._inputBoxDocumentUri; }
     get contextValue() { return this._contextValue; }
     get commitTemplate() { return this.features.commitTemplate || ''; }
+    get historyProvider() { return this._historyProvider; }
     get acceptInputCommand() { return this.features.acceptInputCommand; }
     get actionButton() { return this.features.actionButton ?? undefined; }
     get statusBarCommands() { return this.features.statusBarCommands; }
@@ -99,6 +154,8 @@ class MainThreadSCMProvider {
         this._onDidChangeCommitTemplate = ( new Emitter());
         this.onDidChangeCommitTemplate = this._onDidChangeCommitTemplate.event;
         this._onDidChangeStatusBarCommands = ( new Emitter());
+        this._onDidChangeHistoryProvider = ( new Emitter());
+        this.onDidChangeHistoryProvider = this._onDidChangeHistoryProvider.event;
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
         this.isSCM = true;
@@ -124,6 +181,14 @@ class MainThreadSCMProvider {
             this._quickDiff.dispose();
             this._quickDiff = undefined;
         }
+        if (features.hasHistoryProvider && !this._historyProvider) {
+            this._historyProvider = ( new MainThreadSCMHistoryProvider(this.proxy, this.handle));
+            this._onDidChangeHistoryProvider.fire();
+        }
+        else if (features.hasHistoryProvider === false && this._historyProvider) {
+            this._historyProvider = undefined;
+            this._onDidChangeHistoryProvider.fire();
+        }
     }
     $registerGroups(_groups) {
         const groups = ( _groups.map(([handle, id, label, features]) => {
@@ -201,6 +266,18 @@ class MainThreadSCMProvider {
         const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
         return result && URI.revive(result);
     }
+    $onDidChangeHistoryProviderActionButton(actionButton) {
+        if (!this._historyProvider) {
+            return;
+        }
+        this._historyProvider.actionButton = actionButton ?? undefined;
+    }
+    $onDidChangeHistoryProviderCurrentHistoryItemGroup(currentHistoryItemGroup) {
+        if (!this._historyProvider) {
+            return;
+        }
+        this._historyProvider.currentHistoryItemGroup = currentHistoryItemGroup ?? undefined;
+    }
     toJSON() {
         return {
             $mid: 5 ,
@@ -358,6 +435,22 @@ let MainThreadSCM = class MainThreadSCM {
             repository.input.validateInput = async () => undefined;
         }
     }
+    $onDidChangeHistoryProviderActionButton(sourceControlHandle, actionButton) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$onDidChangeHistoryProviderActionButton(actionButton);
+    }
+    $onDidChangeHistoryProviderCurrentHistoryItemGroup(sourceControlHandle, historyItemGroup) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$onDidChangeHistoryProviderCurrentHistoryItemGroup(historyItemGroup);
+    }
 };
 MainThreadSCM = __decorate([
     extHostNamedCustomer(MainContext.MainThreadSCM),

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

@@ -1,103 +1,18 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ICredentialsService } from '../../../platform/credentials/common/credentials.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { SequencerByKey } from 'monaco-editor/esm/vs/base/common/async.js';
 import { ISecretStorageService } from '../../../platform/secrets/common/secrets.js';
 import { IBrowserWorkbenchEnvironmentService } from '../../services/environment/browser/environmentService.js';
-import { IEncryptionService } from '../../../platform/encryption/common/encryptionService.js';
-class OldMainThreadSecretState extends Disposable {
-    constructor(_proxy, credentialsService, encryptionService, logService) {
-        super();
-        this._proxy = _proxy;
-        this.credentialsService = credentialsService;
-        this.encryptionService = encryptionService;
-        this.logService = logService;
-        this.secretStoragePrefix = this.credentialsService.getSecretStoragePrefix();
-        this._register(this.credentialsService.onDidChangePassword(async (e) => {
-            const extensionId = e.service?.substring((await this.secretStoragePrefix).length);
-            if (extensionId) {
-                this._proxy.$onDidChangePassword({ extensionId, key: e.account });
-            }
-        }));
-    }
-    async getFullKey(extensionId) {
-        return `${await this.secretStoragePrefix}${extensionId}`;
-    }
-    async $getPassword(extensionId, key) {
-        this.logService.trace(`MainThreadSecretState#getPassword: Getting password for ${extensionId} extension: `, key);
-        const fullKey = await this.getFullKey(extensionId);
-        const password = await this.credentialsService.getPassword(fullKey, key);
-        if (!password) {
-            this.logService.trace('MainThreadSecretState#getPassword: No password found for: ', key);
-            return undefined;
-        }
-        let decrypted;
-        try {
-            this.logService.trace('MainThreadSecretState#getPassword: Decrypting password for: ', key);
-            decrypted = await this.encryptionService.decrypt(password);
-        }
-        catch (e) {
-            this.logService.error(e);
-            this.logService.trace('MainThreadSecretState#getPassword: Trying migration for: ', key);
-            const encryptedForSet = await this.encryptionService.encrypt(password);
-            await this.credentialsService.setPassword(fullKey, key, encryptedForSet);
-            const passwordEncrypted = await this.credentialsService.getPassword(fullKey, key);
-            decrypted = passwordEncrypted && (await this.encryptionService.decrypt(passwordEncrypted));
-        }
-        if (decrypted) {
-            try {
-                const value = JSON.parse(decrypted);
-                if (value.extensionId === extensionId) {
-                    this.logService.trace('MainThreadSecretState#getPassword: Password found for: ', key);
-                    return value.content;
-                }
-            }
-            catch (parseError) {
-                this.logService.error(parseError);
-                throw new Error('Unable to parse decrypted password');
-            }
-        }
-        this.logService.trace('MainThreadSecretState#getPassword: No password found for: ', key);
-        return undefined;
-    }
-    async $setPassword(extensionId, key, value) {
-        this.logService.trace(`MainThreadSecretState#setPassword: Setting password for ${extensionId} extension: `, key);
-        const fullKey = await this.getFullKey(extensionId);
-        const toEncrypt = JSON.stringify({
-            extensionId,
-            content: value
-        });
-        this.logService.trace('MainThreadSecretState#setPassword: Encrypting password for: ', key);
-        const encrypted = await this.encryptionService.encrypt(toEncrypt);
-        this.logService.trace('MainThreadSecretState#setPassword: Storing password for: ', key);
-        return await this.credentialsService.setPassword(fullKey, key, encrypted);
-    }
-    async $deletePassword(extensionId, key) {
-        try {
-            const fullKey = await this.getFullKey(extensionId);
-            await this.credentialsService.deletePassword(fullKey, key);
-        }
-        catch (_) {
-            throw new Error('Cannot delete password');
-        }
-    }
-}
 let MainThreadSecretState = class MainThreadSecretState extends Disposable {
-    constructor(extHostContext, secretStorageService, logService, credentialsService, encryptionService, environmentService) {
+    constructor(extHostContext, secretStorageService, logService, environmentService) {
         super();
         this.secretStorageService = secretStorageService;
         this.logService = logService;
-        this.credentialsService = credentialsService;
-        this.encryptionService = encryptionService;
         this._sequencer = ( new SequencerByKey());
-        this.secretStoragePrefix = this.credentialsService.getSecretStoragePrefix();
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSecretState));
-        if (environmentService.options?.credentialsProvider && !environmentService.options?.secretStorageProvider) {
-            this._oldMainThreadSecretState = this._register(( new OldMainThreadSecretState(this._proxy, credentialsService, encryptionService, logService)));
-        }
         this._register(this.secretStorageService.onDidChangeSecret((e) => {
             try {
                 const { extensionId, key } = this.parseKey(e);
@@ -114,17 +29,9 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
         return this._sequencer.queue(extensionId, () => this.doGetPassword(extensionId, key));
     }
     async doGetPassword(extensionId, key) {
-        if (this._oldMainThreadSecretState) {
-            return await this._oldMainThreadSecretState.$getPassword(extensionId, key);
-        }
         const fullKey = this.getKey(extensionId, key);
         const password = await this.secretStorageService.get(fullKey);
-        if (!password) {
-            this.logService.trace('[mainThreadSecretState] No password found for: ', extensionId, key);
-            const password = await this.getAndDeleteOldPassword(extensionId, key);
-            return password;
-        }
-        this.logService.trace('[mainThreadSecretState] Password found for: ', extensionId, key);
+        this.logService.trace(`[mainThreadSecretState] ${password ? 'P' : 'No p'}assword found for: `, extensionId, key);
         return password;
     }
     $setPassword(extensionId, key, value) {
@@ -132,9 +39,6 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
         return this._sequencer.queue(extensionId, () => this.doSetPassword(extensionId, key, value));
     }
     async doSetPassword(extensionId, key, value) {
-        if (this._oldMainThreadSecretState) {
-            return await this._oldMainThreadSecretState.$setPassword(extensionId, key, value);
-        }
         const fullKey = this.getKey(extensionId, key);
         await this.secretStorageService.set(fullKey, value);
         this.logService.trace('[mainThreadSecretState] Password set for: ', extensionId, key);
@@ -144,9 +48,6 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
         return this._sequencer.queue(extensionId, () => this.doDeletePassword(extensionId, key));
     }
     async doDeletePassword(extensionId, key) {
-        if (this._oldMainThreadSecretState) {
-            return await this._oldMainThreadSecretState.$deletePassword(extensionId, key);
-        }
         const fullKey = this.getKey(extensionId, key);
         await this.secretStorageService.delete(fullKey);
         this.logService.trace('[mainThreadSecretState] Password deleted for: ', extensionId, key);
@@ -157,75 +58,11 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
     parseKey(key) {
         return JSON.parse(key);
     }
-    async getAndDeleteOldPassword(extensionId, key) {
-        const password = await this.getOldPassword(extensionId, key);
-        if (password) {
-            const fullKey = this.getKey(extensionId, key);
-            this.logService.trace('[mainThreadSecretState] Setting old password to new location for: ', extensionId, key);
-            await this.secretStorageService.set(fullKey, password);
-            this.logService.trace('[mainThreadSecretState] Old Password set to new location for: ', extensionId, key);
-            if (this.secretStorageService.type === 'persisted') {
-                this.logService.trace('[mainThreadSecretState] Deleting old password for since it was persisted in the new location: ', extensionId, key);
-                await this.deleteOldPassword(extensionId, key);
-            }
-        }
-        return password;
-    }
-    async getOldPassword(extensionId, key) {
-        this.logService.trace(`[mainThreadSecretState] Getting old password for ${extensionId} extension: `, key);
-        const fullKey = `${await this.secretStoragePrefix}${extensionId}`;
-        const password = await this.credentialsService.getPassword(fullKey, key);
-        if (!password) {
-            this.logService.trace('[mainThreadSecretState] No old password found for: ', extensionId, key);
-            return undefined;
-        }
-        let decrypted;
-        try {
-            this.logService.trace('[mainThreadSecretState] Decrypting old password for: ', extensionId, key);
-            decrypted = await this.encryptionService.decrypt(password);
-        }
-        catch (e) {
-            this.logService.error(e);
-            this.logService.trace('[mainThreadSecretState] Trying old migration for: ', extensionId, key);
-            const encryptedForSet = await this.encryptionService.encrypt(password);
-            await this.credentialsService.setPassword(fullKey, key, encryptedForSet);
-            const passwordEncrypted = await this.credentialsService.getPassword(fullKey, key);
-            decrypted = passwordEncrypted && (await this.encryptionService.decrypt(passwordEncrypted));
-        }
-        if (decrypted) {
-            try {
-                const value = JSON.parse(decrypted);
-                if (value.extensionId === extensionId) {
-                    this.logService.trace('[mainThreadSecretState] Old password found for: ', extensionId, key);
-                    return value.content;
-                }
-            }
-            catch (parseError) {
-                this.logService.error(parseError);
-                return undefined;
-            }
-        }
-        this.logService.trace('[mainThreadSecretState] No old password found for: ', extensionId, key);
-        return undefined;
-    }
-    async deleteOldPassword(extensionId, key) {
-        try {
-            const fullKey = `${await this.secretStoragePrefix}${extensionId}`;
-            this.logService.trace(`[mainThreadSecretState] Deleting old password for ${extensionId} extension: `, key);
-            await this.credentialsService.deletePassword(fullKey, key);
-            this.logService.trace('[mainThreadSecretState] Old password deleted for: ', extensionId, key);
-        }
-        catch (_) {
-            throw new Error('Cannot delete password');
-        }
-    }
 };
 MainThreadSecretState = __decorate([
     extHostNamedCustomer(MainContext.MainThreadSecretState),
     ( __param(1, ISecretStorageService)),
     ( __param(2, ILogService)),
-    ( __param(3, ICredentialsService)),
-    ( __param(4, IEncryptionService)),
-    ( __param(5, IBrowserWorkbenchEnvironmentService))
+    ( __param(3, IBrowserWorkbenchEnvironmentService))
 ], MainThreadSecretState);
 export { MainThreadSecretState };

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

@@ -425,6 +425,9 @@ let MainThreadTask = class MainThreadTask {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTask));
         this._providers = ( new Map());
         this._taskService.onDidStateChange(async (event) => {
+            if (event.kind === "changed" ) {
+                return;
+            }
             const task = event.__task;
             if (event.kind === "start" ) {
                 const execution = TaskExecutionDTO.from(task.getTaskExecution());