@codingame/monaco-vscode-extensions-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,208 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableMap, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IFileService, FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, toFileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+
+var MainThreadFileSystem_1;
+let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
+    constructor(extHostContext, _fileService) {
+        this._fileService = _fileService;
+        this._fileProvider = ( new DisposableMap());
+        this._disposables = ( new DisposableStore());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystem));
+        const infoProxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo));
+        for (const entry of _fileService.listCapabilities()) {
+            infoProxy.$acceptProviderInfos(( URI.from({ scheme: entry.scheme, path: '/dummy' })), entry.capabilities);
+        }
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider?.capabilities ?? null)));
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider.capabilities)));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._fileProvider.dispose();
+    }
+    async $registerFileSystemProvider(handle, scheme, capabilities, readonlyMessage) {
+        this._fileProvider.set(handle, ( new RemoteFileSystemProvider(
+            this._fileService,
+            scheme,
+            capabilities,
+            readonlyMessage,
+            handle,
+            this._proxy
+        )));
+    }
+    $unregisterProvider(handle) {
+        this._fileProvider.deleteAndDispose(handle);
+    }
+    $onFileSystemChange(handle, changes) {
+        const fileProvider = this._fileProvider.get(handle);
+        if (!fileProvider) {
+            throw new Error('Unknown file provider');
+        }
+        fileProvider.$onFileSystemChange(changes);
+    }
+    $stat(uri) {
+        return this._fileService.stat(URI.revive(uri)).then(stat => {
+            return {
+                ctime: stat.ctime,
+                mtime: stat.mtime,
+                size: stat.size,
+                permissions: stat.readonly ? FilePermission.Readonly : undefined,
+                type: MainThreadFileSystem_1._asFileType(stat)
+            };
+        }).catch(MainThreadFileSystem_1._handleError);
+    }
+    $readdir(uri) {
+        return this._fileService.resolve(URI.revive(uri), { resolveMetadata: false }).then(stat => {
+            if (!stat.isDirectory) {
+                const err = ( new Error(stat.name));
+                err.name = FileSystemProviderErrorCode.FileNotADirectory;
+                throw err;
+            }
+            return !stat.children ? [] : ( stat.children.map(child => [child.name, MainThreadFileSystem_1._asFileType(child)]));
+        }).catch(MainThreadFileSystem_1._handleError);
+    }
+    static _asFileType(stat) {
+        let res = 0;
+        if (stat.isFile) {
+            res += FileType.File;
+        }
+        else if (stat.isDirectory) {
+            res += FileType.Directory;
+        }
+        if (stat.isSymbolicLink) {
+            res += FileType.SymbolicLink;
+        }
+        return res;
+    }
+    $readFile(uri) {
+        return this._fileService.readFile(URI.revive(uri)).then(file => file.value).catch(MainThreadFileSystem_1._handleError);
+    }
+    $writeFile(uri, content) {
+        return this._fileService.writeFile(URI.revive(uri), content)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $rename(source, target, opts) {
+        return this._fileService.move(URI.revive(source), URI.revive(target), opts.overwrite)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $copy(source, target, opts) {
+        return this._fileService.copy(URI.revive(source), URI.revive(target), opts.overwrite)
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $mkdir(uri) {
+        return this._fileService.createFolder(URI.revive(uri))
+            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
+    }
+    $delete(uri, opts) {
+        return this._fileService.del(URI.revive(uri), opts).catch(MainThreadFileSystem_1._handleError);
+    }
+    static _handleError(err) {
+        if (err instanceof FileOperationError) {
+            switch (err.fileOperationResult) {
+                case 1 :
+                    err.name = FileSystemProviderErrorCode.FileNotFound;
+                    break;
+                case 0 :
+                    err.name = FileSystemProviderErrorCode.FileIsADirectory;
+                    break;
+                case 6 :
+                    err.name = FileSystemProviderErrorCode.NoPermissions;
+                    break;
+                case 4 :
+                    err.name = FileSystemProviderErrorCode.FileExists;
+                    break;
+            }
+        }
+        else if (err instanceof Error) {
+            const code = toFileSystemProviderErrorCode(err);
+            if (code !== FileSystemProviderErrorCode.Unknown) {
+                err.name = code;
+            }
+        }
+        throw err;
+    }
+    $ensureActivation(scheme) {
+        return this._fileService.activateProvider(scheme);
+    }
+};
+MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadFileSystem),
+    ( __param(1, IFileService))
+], MainThreadFileSystem);
+class RemoteFileSystemProvider {
+    constructor(fileService, scheme, capabilities, readOnlyMessage, _handle, _proxy) {
+        this.readOnlyMessage = readOnlyMessage;
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._onDidChange = ( new Emitter());
+        this.onDidChangeFile = this._onDidChange.event;
+        this.onDidChangeCapabilities = Event.None;
+        this.capabilities = capabilities;
+        this._registration = fileService.registerProvider(scheme, this);
+    }
+    dispose() {
+        this._registration.dispose();
+        this._onDidChange.dispose();
+    }
+    watch(resource, opts) {
+        const session = Math.random();
+        this._proxy.$watch(this._handle, session, resource, opts);
+        return toDisposable(() => {
+            this._proxy.$unwatch(this._handle, session);
+        });
+    }
+    $onFileSystemChange(changes) {
+        this._onDidChange.fire(( changes.map(RemoteFileSystemProvider._createFileChange)));
+    }
+    static _createFileChange(dto) {
+        return { resource: URI.revive(dto.resource), type: dto.type };
+    }
+    stat(resource) {
+        return this._proxy.$stat(this._handle, resource).then(undefined, err => {
+            throw err;
+        });
+    }
+    readFile(resource) {
+        return this._proxy.$readFile(this._handle, resource).then(buffer => buffer.buffer);
+    }
+    writeFile(resource, content, opts) {
+        return this._proxy.$writeFile(this._handle, resource, VSBuffer.wrap(content), opts);
+    }
+    delete(resource, opts) {
+        return this._proxy.$delete(this._handle, resource, opts);
+    }
+    mkdir(resource) {
+        return this._proxy.$mkdir(this._handle, resource);
+    }
+    readdir(resource) {
+        return this._proxy.$readdir(this._handle, resource);
+    }
+    rename(resource, target, opts) {
+        return this._proxy.$rename(this._handle, resource, target, opts);
+    }
+    copy(resource, target, opts) {
+        return this._proxy.$copy(this._handle, resource, target, opts);
+    }
+    open(resource, opts) {
+        return this._proxy.$open(this._handle, resource, opts);
+    }
+    close(fd) {
+        return this._proxy.$close(this._handle, fd);
+    }
+    read(fd, pos, data, offset, length) {
+        return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
+            data.set(readData.buffer, offset);
+            return readData.byteLength;
+        });
+    }
+    write(fd, pos, data, offset, length) {
+        return this._proxy.$write(this._handle, fd, pos, VSBuffer.wrap(data).slice(offset, offset + length));
+    }
+}
+
+export { MainThreadFileSystem };

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

@@ -0,0 +1,369 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
+import { GLOBSTAR } from 'vscode/vscode/vs/base/common/glob';
+import { rtrim } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { normalizeWatcherPattern } from 'vscode/vscode/vs/platform/files/common/watcher';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var MainThreadFileSystemEventService_1;
+let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
+    static { MainThreadFileSystemEventService_1 = this; }
+    static { this.MementoKeyAdditionalEdits = `file.particpants.additionalEdits`; }
+    constructor(extHostContext, _fileService, workingCopyFileService, bulkEditService, progressService, dialogService, storageService, logService, envService, uriIdentService, _contextService, _logService, _configurationService) {
+        this._fileService = _fileService;
+        this._contextService = _contextService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._listener = ( new DisposableStore());
+        this._watches = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
+        this._listener.add(_fileService.onDidFilesChange(event => {
+            this._proxy.$onFileEvent({
+                created: event.rawAdded,
+                changed: event.rawUpdated,
+                deleted: event.rawDeleted
+            });
+        }));
+        const that = this;
+        const fileOperationParticipant = new (class {
+            async participate(files, operation, undoInfo, timeout, token) {
+                if (undoInfo?.isUndoing) {
+                    return;
+                }
+                const cts = ( new CancellationTokenSource(token));
+                const timer = setTimeout(() => cts.cancel(), timeout);
+                const data = await progressService.withProgress({
+                    location: 15 ,
+                    title: this._progressLabel(operation),
+                    cancellable: true,
+                    delay: Math.min(timeout / 2, 3000)
+                }, () => {
+                    const onWillEvent = that._proxy.$onWillRunFileOperation(operation, files, timeout, cts.token);
+                    return raceCancellation(onWillEvent, cts.token);
+                }, () => {
+                    cts.cancel();
+                }).finally(() => {
+                    cts.dispose();
+                    clearTimeout(timer);
+                });
+                if (!data || data.edit.edits.length === 0) {
+                    return;
+                }
+                const needsConfirmation = ( data.edit.edits.some(edit => edit.metadata?.needsConfirmation));
+                let showPreview = storageService.getBoolean(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, 0 );
+                if (envService.extensionTestsLocationURI) {
+                    showPreview = false;
+                }
+                if (showPreview === undefined) {
+                    let message;
+                    if (data.extensionNames.length === 1) {
+                        if (operation === 0 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'ask.1.create',
+                                "Extension '{0}' wants to make refactoring changes with this file creation",
+                                data.extensionNames[0]
+                            ));
+                        }
+                        else if (operation === 3 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'ask.1.copy',
+                                "Extension '{0}' wants to make refactoring changes with this file copy",
+                                data.extensionNames[0]
+                            ));
+                        }
+                        else if (operation === 2 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'ask.1.move',
+                                "Extension '{0}' wants to make refactoring changes with this file move",
+                                data.extensionNames[0]
+                            ));
+                        }
+                        else  {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'ask.1.delete',
+                                "Extension '{0}' wants to make refactoring changes with this file deletion",
+                                data.extensionNames[0]
+                            ));
+                        }
+                    }
+                    else {
+                        if (operation === 0 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                { key: 'ask.N.create', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                "{0} extensions want to make refactoring changes with this file creation",
+                                data.extensionNames.length
+                            ));
+                        }
+                        else if (operation === 3 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                { key: 'ask.N.copy', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                "{0} extensions want to make refactoring changes with this file copy",
+                                data.extensionNames.length
+                            ));
+                        }
+                        else if (operation === 2 ) {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                { key: 'ask.N.move', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                "{0} extensions want to make refactoring changes with this file move",
+                                data.extensionNames.length
+                            ));
+                        }
+                        else  {
+                            message = ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                { key: 'ask.N.delete', comment: ['{0} is a number, e.g "3 extensions want..."'] },
+                                "{0} extensions want to make refactoring changes with this file deletion",
+                                data.extensionNames.length
+                            ));
+                        }
+                    }
+                    if (needsConfirmation) {
+                        const { confirmed } = await dialogService.confirm({
+                            type: Severity$1.Info,
+                            message,
+                            primaryButton: ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'preview',
+                                "Show &&Preview"
+                            )),
+                            cancelButton: ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'cancel',
+                                "Skip Changes"
+                            ))
+                        });
+                        showPreview = true;
+                        if (!confirmed) {
+                            return;
+                        }
+                    }
+                    else {
+                        let Choice;
+                        ( (function(Choice) {
+                            Choice[Choice["OK"] = 0] = "OK";
+                            Choice[Choice["Preview"] = 1] = "Preview";
+                            Choice[Choice["Cancel"] = 2] = "Cancel";
+                        })(Choice || (Choice = {})));
+                        const { result, checkboxChecked } = await dialogService.prompt({
+                            type: Severity$1.Info,
+                            message,
+                            buttons: [
+                                {
+                                    label: ( localizeWithPath(
+                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
+                                        "&&OK"
+                                    )),
+                                    run: () => Choice.OK
+                                },
+                                {
+                                    label: ( localizeWithPath(
+                                        'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                        { key: 'preview', comment: ['&& denotes a mnemonic'] },
+                                        "Show &&Preview"
+                                    )),
+                                    run: () => Choice.Preview
+                                }
+                            ],
+                            cancelButton: {
+                                label: ( localizeWithPath(
+                                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                    'cancel',
+                                    "Skip Changes"
+                                )),
+                                run: () => Choice.Cancel
+                            },
+                            checkbox: { label: ( localizeWithPath(
+                                'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                                'again',
+                                "Do not ask me again"
+                            )) }
+                        });
+                        if (result === Choice.Cancel) {
+                            return;
+                        }
+                        showPreview = result === Choice.Preview;
+                        if (checkboxChecked) {
+                            storageService.store(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, showPreview, 0 , 0 );
+                        }
+                    }
+                }
+                logService.info('[onWill-handler] applying additional workspace edit from extensions', data.extensionNames);
+                await bulkEditService.apply(reviveWorkspaceEditDto(data.edit, uriIdentService), { undoRedoGroupId: undoInfo?.undoRedoGroupId, showPreview });
+            }
+            _progressLabel(operation) {
+                switch (operation) {
+                    case 0 :
+                        return ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                            'msg-create',
+                            "Running 'File Create' participants..."
+                        ));
+                    case 2 :
+                        return ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                            'msg-rename',
+                            "Running 'File Rename' participants..."
+                        ));
+                    case 3 :
+                        return ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                            'msg-copy',
+                            "Running 'File Copy' participants..."
+                        ));
+                    case 1 :
+                        return ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                            'msg-delete',
+                            "Running 'File Delete' participants..."
+                        ));
+                    case 4 :
+                        return ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                            'msg-write',
+                            "Running 'File Write' participants..."
+                        ));
+                }
+            }
+        });
+        this._listener.add(workingCopyFileService.addFileOperationParticipant(fileOperationParticipant));
+        this._listener.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this._proxy.$onDidRunFileOperation(e.operation, e.files)));
+    }
+    async $watch(extensionId, session, resource, unvalidatedOpts, correlate) {
+        const uri = URI.revive(resource);
+        const opts = {
+            ...unvalidatedOpts
+        };
+        if (opts.recursive) {
+            try {
+                const stat = await this._fileService.stat(uri);
+                if (!stat.isDirectory) {
+                    opts.recursive = false;
+                }
+            }
+            catch (error) {
+            }
+        }
+        if (correlate) {
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            const watcherDisposables = ( new DisposableStore());
+            const subscription = watcherDisposables.add(this._fileService.createWatcher(uri, opts));
+            watcherDisposables.add(subscription.onDidChange(event => {
+                this._proxy.$onFileEvent({
+                    session,
+                    created: event.rawAdded,
+                    changed: event.rawUpdated,
+                    deleted: event.rawDeleted
+                });
+            }));
+            this._watches.set(session, watcherDisposables);
+        }
+        else {
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
+            if (opts.recursive && opts.excludes.length === 0) {
+                const config = this._configurationService.getValue();
+                if (config.files?.watcherExclude) {
+                    for (const key in config.files.watcherExclude) {
+                        if (key && config.files.watcherExclude[key] === true) {
+                            opts.excludes.push(key);
+                        }
+                    }
+                }
+            }
+            else if (!opts.recursive && workspaceFolder) {
+                const config = this._configurationService.getValue();
+                if (config.files?.watcherExclude) {
+                    for (const key in config.files.watcherExclude) {
+                        if (key && config.files.watcherExclude[key] === true) {
+                            if (!opts.includes) {
+                                opts.includes = [];
+                            }
+                            const includePattern = `${rtrim(key, '/')}/${GLOBSTAR}`;
+                            opts.includes.push(normalizeWatcherPattern(workspaceFolder.uri.fsPath, includePattern));
+                        }
+                    }
+                }
+                if (!opts.includes || opts.includes.length === 0) {
+                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+                    return;
+                }
+            }
+            const subscription = this._fileService.watch(uri, opts);
+            this._watches.set(session, subscription);
+        }
+    }
+    $unwatch(session) {
+        if (( this._watches.has(session))) {
+            this._logService.trace(`MainThreadFileSystemEventService#$unwatch(): request to stop watching (session: ${session})`);
+            this._watches.deleteAndDispose(session);
+        }
+    }
+    dispose() {
+        this._listener.dispose();
+        this._watches.dispose();
+    }
+};
+MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadFileSystemEventService),
+    ( __param(1, IFileService)),
+    ( __param(2, IWorkingCopyFileService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, IProgressService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IEnvironmentService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, ILogService)),
+    ( __param(12, IConfigurationService))
+], MainThreadFileSystemEventService);
+registerAction2(class ResetMemento extends Action2 {
+    constructor() {
+        super({
+            id: 'files.participants.resetChoice',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadFileSystemEventService',
+                    'label',
+                    "Reset choice for 'File operation needs preview'"
+                )),
+                original: `Reset choice for 'File operation needs preview'`
+            },
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IStorageService).remove(MainThreadFileSystemEventService.MementoKeyAdditionalEdits, 0 );
+    }
+});
+
+export { MainThreadFileSystemEventService };

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

@@ -0,0 +1,72 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadInlineChat = class MainThreadInlineChat {
+    constructor(extHostContext, _inlineChatService, _uriIdentService) {
+        this._inlineChatService = _inlineChatService;
+        this._uriIdentService = _uriIdentService;
+        this._registrations = ( new DisposableMap());
+        this._progresses = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostInlineChat));
+    }
+    dispose() {
+        this._registrations.dispose();
+    }
+    async $registerInteractiveEditorProvider(handle, label, extensionId, supportsFeedback, supportsFollowups, supportIssueReporting) {
+        const unreg = this._inlineChatService.addProvider({
+            extensionId,
+            label,
+            supportIssueReporting,
+            prepareInlineChatSession: async (model, range, token) => {
+                const session = await this._proxy.$prepareSession(handle, model.uri, range, token);
+                if (!session) {
+                    return undefined;
+                }
+                return {
+                    ...session,
+                    dispose: () => {
+                        this._proxy.$releaseSession(handle, session.id);
+                    }
+                };
+            },
+            provideResponse: async (item, request, progress, token) => {
+                this._progresses.set(request.requestId, progress);
+                try {
+                    const result = await this._proxy.$provideResponse(handle, item, request, token);
+                    if (result?.type === 'bulkEdit') {
+                        result.edits = reviveWorkspaceEditDto(result.edits, this._uriIdentService);
+                    }
+                    return result;
+                }
+                finally {
+                    this._progresses.delete(request.requestId);
+                }
+            },
+            provideFollowups: !supportsFollowups ? undefined : async (session, response, token) => {
+                return this._proxy.$provideFollowups(handle, session.id, response.id, token);
+            },
+            handleInlineChatResponseFeedback: !supportsFeedback ? undefined : async (session, response, kind) => {
+                this._proxy.$handleFeedback(handle, session.id, response.id, kind);
+            }
+        });
+        this._registrations.set(handle, unreg);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        await Promise.resolve(this._progresses.get(requestId)?.report(chunk));
+    }
+    async $unregisterInteractiveEditorProvider(handle) {
+        this._registrations.deleteAndDispose(handle);
+    }
+};
+MainThreadInlineChat = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadInlineChat),
+    ( __param(1, IInlineChatService)),
+    ( __param(2, IUriIdentityService))
+], MainThreadInlineChat);
+
+export { MainThreadInlineChat };