@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

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

@@ -0,0 +1,280 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, toFileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkbenchFileService } from 'vscode/vscode/vs/workbench/services/files/common/files';
+import { normalizeWatcherPattern } from '../../../platform/files/common/watcher.js';
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
+
+var MainThreadFileSystem_1;
+let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
+    constructor(extHostContext, _fileService, _contextService, _logService, _configurationService) {
+        this._fileService = _fileService;
+        this._contextService = _contextService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._fileProvider = ( new DisposableMap());
+        this._disposables = ( new DisposableStore());
+        this._watches = ( new DisposableMap());
+        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();
+        this._watches.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);
+    }
+    async $watch(extensionId, session, resource, unvalidatedOpts) {
+        const uri = URI.revive(resource);
+        const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
+        const opts = { ...unvalidatedOpts };
+        if (opts.recursive) {
+            try {
+                const stat = await this._fileService.stat(uri);
+                if (!stat.isDirectory) {
+                    opts.recursive = false;
+                }
+            }
+            catch (error) {
+                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
+            }
+        }
+        if (workspaceFolder && opts.recursive) {
+            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            return;
+        }
+        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+        if (opts.recursive) {
+            const config = this._configurationService.getValue();
+            if (config.files?.watcherExclude) {
+                for (const key in config.files.watcherExclude) {
+                    if (config.files.watcherExclude[key] === true) {
+                        opts.excludes.push(key);
+                    }
+                }
+            }
+        }
+        else if (workspaceFolder) {
+            const config = this._configurationService.getValue();
+            if (config.files?.watcherExclude) {
+                for (const key in config.files.watcherExclude) {
+                    if (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(`MainThreadFileSystem#$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(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
+            this._watches.deleteAndDispose(session);
+        }
+    }
+};
+MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadFileSystem),
+    ( __param(1, IWorkbenchFileService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IConfigurationService))
+], 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,283 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
+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) {
+        this._listener = ( new DisposableStore());
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
+        this._listener.add(fileService.onDidFilesChange(event => {
+            proxy.$onFileEvent({
+                created: event.rawAdded,
+                changed: event.rawUpdated,
+                deleted: event.rawDeleted
+            });
+        }));
+        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 = 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.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.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',
+                                "Don't ask 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 => proxy.$onDidRunFileOperation(e.operation, e.files)));
+    }
+    dispose() {
+        this._listener.dispose();
+    }
+};
+MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
+    extHostCustomer,
+    ( __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))
+], 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,68 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+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, debugName, supportsFeedback) {
+        const unreg = this._inlineChatService.addProvider({
+            debugName,
+            label,
+            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);
+                }
+            },
+            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) {
+        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 };

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

@@ -0,0 +1,28 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IInteractiveDocumentService } from 'vscode/vscode/vs/workbench/contrib/interactive/browser/interactiveDocumentService';
+
+let MainThreadInteractive = class MainThreadInteractive {
+    constructor(extHostContext, interactiveDocumentService) {
+        this._disposables = ( new DisposableStore());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostInteractive));
+        this._disposables.add(interactiveDocumentService.onWillAddInteractiveDocument((e) => {
+            this._proxy.$willAddInteractiveDocument(e.inputUri, '\n', PLAINTEXT_LANGUAGE_ID, e.notebookUri);
+        }));
+        this._disposables.add(interactiveDocumentService.onWillRemoveInteractiveDocument((e) => {
+            this._proxy.$willRemoveInteractiveDocument(e.inputUri, e.notebookUri);
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+};
+MainThreadInteractive = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadInteractive),
+    ( __param(1, IInteractiveDocumentService))
+], MainThreadInteractive);
+
+export { MainThreadInteractive };