@codingame/monaco-vscode-extensions-service-override 4.5.1 → 5.0.0

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

@@ -4,6 +4,7 @@ import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
 import { isString } from 'vscode/vscode/vs/base/common/types';
 import { platform } from 'vscode/vscode/vs/base/common/platform';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, CustomTask, ContributedTask, ConfiguringTask } from 'vscode/vscode/vs/workbench/contrib/tasks/common/tasks';
 import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService.service';
@@ -12,8 +13,9 @@ import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/comm
 import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadTask";
 var TaskExecutionDTO;
-( (function(TaskExecutionDTO) {
+( ((function(TaskExecutionDTO) {
     function from(value) {
         return {
             id: value.id,
@@ -21,9 +23,9 @@ var TaskExecutionDTO;
         };
     }
     TaskExecutionDTO.from = from;
-})(TaskExecutionDTO || (TaskExecutionDTO = {})));
+})(TaskExecutionDTO || (TaskExecutionDTO = {}))));
 var TaskProcessStartedDTO;
-( (function(TaskProcessStartedDTO) {
+( ((function(TaskProcessStartedDTO) {
     function from(value, processId) {
         return {
             id: value.id,
@@ -31,9 +33,9 @@ var TaskProcessStartedDTO;
         };
     }
     TaskProcessStartedDTO.from = from;
-})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {})));
+})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {}))));
 var TaskProcessEndedDTO;
-( (function(TaskProcessEndedDTO) {
+( ((function(TaskProcessEndedDTO) {
     function from(value, exitCode) {
         return {
             id: value.id,
@@ -41,9 +43,9 @@ var TaskProcessEndedDTO;
         };
     }
     TaskProcessEndedDTO.from = from;
-})(TaskProcessEndedDTO || (TaskProcessEndedDTO = {})));
+})(TaskProcessEndedDTO || (TaskProcessEndedDTO = {}))));
 var TaskDefinitionDTO;
-( (function(TaskDefinitionDTO) {
+( ((function(TaskDefinitionDTO) {
     function from(value) {
         const result = Object.assign(Object.create(null), value);
         delete result._key;
@@ -61,9 +63,9 @@ var TaskDefinitionDTO;
         return result;
     }
     TaskDefinitionDTO.to = to;
-})(TaskDefinitionDTO || (TaskDefinitionDTO = {})));
+})(TaskDefinitionDTO || (TaskDefinitionDTO = {}))));
 var TaskPresentationOptionsDTO;
-( (function(TaskPresentationOptionsDTO) {
+( ((function(TaskPresentationOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -78,9 +80,9 @@ var TaskPresentationOptionsDTO;
         return Object.assign(Object.create(null), PresentationOptions.defaults, value);
     }
     TaskPresentationOptionsDTO.to = to;
-})(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {})));
+})(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {}))));
 var RunOptionsDTO;
-( (function(RunOptionsDTO) {
+( ((function(RunOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -95,9 +97,9 @@ var RunOptionsDTO;
         return Object.assign(Object.create(null), RunOptions.defaults, value);
     }
     RunOptionsDTO.to = to;
-})(RunOptionsDTO || (RunOptionsDTO = {})));
+})(RunOptionsDTO || (RunOptionsDTO = {}))));
 var ProcessExecutionOptionsDTO;
-( (function(ProcessExecutionOptionsDTO) {
+( ((function(ProcessExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -118,9 +120,9 @@ var ProcessExecutionOptionsDTO;
         };
     }
     ProcessExecutionOptionsDTO.to = to;
-})(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {})));
+})(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {}))));
 var ProcessExecutionDTO;
-( (function(ProcessExecutionDTO) {
+( ((function(ProcessExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && !!candidate.process;
@@ -128,7 +130,7 @@ var ProcessExecutionDTO;
     ProcessExecutionDTO.is = is;
     function from(value) {
         const process = isString(value.name) ? value.name : value.name.value;
-        const args = value.args ? ( value.args.map(value => isString(value) ? value : value.value)) : [];
+        const args = value.args ? ( (value.args.map(value => isString(value) ? value : value.value))) : [];
         const result = {
             process: process,
             args: args
@@ -150,9 +152,9 @@ var ProcessExecutionDTO;
         return result;
     }
     ProcessExecutionDTO.to = to;
-})(ProcessExecutionDTO || (ProcessExecutionDTO = {})));
+})(ProcessExecutionDTO || (ProcessExecutionDTO = {}))));
 var ShellExecutionOptionsDTO;
-( (function(ShellExecutionOptionsDTO) {
+( ((function(ShellExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -191,9 +193,9 @@ var ShellExecutionOptionsDTO;
         return result;
     }
     ShellExecutionOptionsDTO.to = to;
-})(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {})));
+})(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {}))));
 var ShellExecutionDTO;
-( (function(ShellExecutionDTO) {
+( ((function(ShellExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && (!!candidate.commandLine || !!candidate.command);
@@ -227,9 +229,9 @@ var ShellExecutionDTO;
         return result;
     }
     ShellExecutionDTO.to = to;
-})(ShellExecutionDTO || (ShellExecutionDTO = {})));
+})(ShellExecutionDTO || (ShellExecutionDTO = {}))));
 var CustomExecutionDTO;
-( (function(CustomExecutionDTO) {
+( ((function(CustomExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && candidate.customExecution === 'customExecution';
@@ -248,9 +250,9 @@ var CustomExecutionDTO;
         };
     }
     CustomExecutionDTO.to = to;
-})(CustomExecutionDTO || (CustomExecutionDTO = {})));
+})(CustomExecutionDTO || (CustomExecutionDTO = {}))));
 var TaskSourceDTO;
-( (function(TaskSourceDTO) {
+( ((function(TaskSourceDTO) {
     function from(value) {
         const result = {
             label: value.label
@@ -301,17 +303,17 @@ var TaskSourceDTO;
         return result;
     }
     TaskSourceDTO.to = to;
-})(TaskSourceDTO || (TaskSourceDTO = {})));
+})(TaskSourceDTO || (TaskSourceDTO = {}))));
 var TaskHandleDTO;
-( (function(TaskHandleDTO) {
+( ((function(TaskHandleDTO) {
     function is(value) {
         const candidate = value;
         return candidate && isString(candidate.id) && !!candidate.workspaceFolder;
     }
     TaskHandleDTO.is = is;
-})(TaskHandleDTO || (TaskHandleDTO = {})));
+})(TaskHandleDTO || (TaskHandleDTO = {}))));
 var TaskDTO;
-( (function(TaskDTO) {
+( ((function(TaskDTO) {
     function from(task) {
         if (task === undefined || task === null || (!CustomTask.is(task) && !ContributedTask.is(task) && !ConfiguringTask.is(task))) {
             return undefined;
@@ -376,32 +378,36 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadTask',
-            'task.label',
-            '{0}: {1}',
-            source.label,
-            task.name
-        ));
+        const label = ( localizeWithPath(_moduleId, 0, '{0}: {1}', source.label, task.name));
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
-        const result = ( new ContributedTask(
-        id, source, label, definition.type, definition, command, task.hasDefinedMatchers, RunOptionsDTO.to(task.runOptions), {
-            name: task.name,
-            identifier: label,
-            group: task.group,
-            isBackground: !!task.isBackground,
-            problemMatchers: task.problemMatchers.slice(),
-            detail: task.detail,
-            icon,
-            hide
-        }));
+        const result = ( (new
+        ContributedTask(
+            id,
+            source,
+            label,
+            definition.type,
+            definition,
+            command,
+            task.hasDefinedMatchers,
+            RunOptionsDTO.to(task.runOptions),
+            {
+                name: task.name,
+                identifier: label,
+                group: task.group,
+                isBackground: !!task.isBackground,
+                problemMatchers: task.problemMatchers.slice(),
+                detail: task.detail,
+                icon,
+                hide
+            }
+        )));
         return result;
     }
     TaskDTO.to = to;
-})(TaskDTO || (TaskDTO = {})));
+})(TaskDTO || (TaskDTO = {}))));
 var TaskGroupDTO;
-( (function(TaskGroupDTO) {
+( ((function(TaskGroupDTO) {
     function from(value) {
         if (value === undefined) {
             return undefined;
@@ -412,9 +418,9 @@ var TaskGroupDTO;
         };
     }
     TaskGroupDTO.from = from;
-})(TaskGroupDTO || (TaskGroupDTO = {})));
+})(TaskGroupDTO || (TaskGroupDTO = {}))));
 var TaskFilterDTO;
-( (function(TaskFilterDTO) {
+( ((function(TaskFilterDTO) {
     function from(value) {
         return value;
     }
@@ -423,15 +429,16 @@ var TaskFilterDTO;
         return value;
     }
     TaskFilterDTO.to = to;
-})(TaskFilterDTO || (TaskFilterDTO = {})));
-let MainThreadTask = class MainThreadTask {
+})(TaskFilterDTO || (TaskFilterDTO = {}))));
+let MainThreadTask = class MainThreadTask extends Disposable {
     constructor(extHostContext, _taskService, _workspaceContextServer, _configurationResolverService) {
+        super();
         this._taskService = _taskService;
         this._workspaceContextServer = _workspaceContextServer;
         this._configurationResolverService = _configurationResolverService;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTask));
-        this._providers = ( new Map());
-        this._taskService.onDidStateChange(async (event) => {
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostTask)));
+        this._providers = ( (new Map()));
+        this._register(this._taskService.onDidStateChange(async (event) => {
             if (event.kind === "changed" ) {
                 return;
             }
@@ -457,24 +464,27 @@ let MainThreadTask = class MainThreadTask {
             else if (event.kind === "end" ) {
                 this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
             }
-        });
+        }));
     }
     dispose() {
-        for (const value of ( this._providers.values())) {
+        for (const value of ( (this._providers.values()))) {
             value.disposable.dispose();
         }
         this._providers.clear();
+        super.dispose();
     }
     $createTaskId(taskDTO) {
-        return ( new Promise((resolve, reject) => {
-            const task = TaskDTO.to(taskDTO, this._workspaceContextServer, true);
-            if (task) {
-                resolve(task._id);
-            }
-            else {
-                reject(( new Error('Task could not be created from DTO')));
-            }
-        }));
+        return (
+             (new Promise((resolve, reject) => {
+                const task = TaskDTO.to(taskDTO, this._workspaceContextServer, true);
+                if (task) {
+                    resolve(task._id);
+                }
+                else {
+                    reject(( (new Error('Task could not be created from DTO'))));
+                }
+            }))
+        );
     }
     $registerTaskProvider(handle, type) {
         const provider = {
@@ -542,7 +552,7 @@ let MainThreadTask = class MainThreadTask {
         else {
             const workspaceObject = this._workspaceContextServer.getWorkspace();
             const uri = URI.revive(value);
-            if (workspaceObject.configuration?.toString() === ( uri.toString())) {
+            if (workspaceObject.configuration?.toString() === ( (uri.toString()))) {
                 workspace = workspaceObject;
             }
             else {
@@ -562,10 +572,10 @@ let MainThreadTask = class MainThreadTask {
                         task: TaskDTO.from(task)
                     };
                 }
-                throw new Error('Task not found');
+                throw ( (new Error('Task not found')));
             }
             else {
-                throw new Error('No workspace folder');
+                throw ( (new Error('No workspace folder')));
             }
         }
         else {
@@ -577,80 +587,86 @@ let MainThreadTask = class MainThreadTask {
         }
     }
     $executeTask(value) {
-        return ( new Promise((resolve, reject) => {
-            if (TaskHandleDTO.is(value)) {
-                const workspace = this.getWorkspace(value.workspaceFolder);
-                if (workspace) {
-                    this._taskService.getTask(workspace, value.id, true).then((task) => {
-                        if (!task) {
-                            reject(( new Error('Task not found')));
-                        }
-                        else {
-                            const result = {
-                                id: value.id,
-                                task: TaskDTO.from(task)
-                            };
-                            this._taskService.run(task).then(summary => {
-                                if ((summary?.exitCode === undefined) || (summary.exitCode !== 0)) {
-                                    this._proxy.$OnDidEndTask(result);
-                                }
-                            }, reason => {
-                            });
-                            resolve(result);
-                        }
-                    }, (_error) => {
-                        reject(( new Error('Task not found')));
-                    });
+        return (
+             (new Promise((resolve, reject) => {
+                if (TaskHandleDTO.is(value)) {
+                    const workspace = this.getWorkspace(value.workspaceFolder);
+                    if (workspace) {
+                        this._taskService.getTask(workspace, value.id, true).then((task) => {
+                            if (!task) {
+                                reject(( (new Error('Task not found'))));
+                            }
+                            else {
+                                const result = {
+                                    id: value.id,
+                                    task: TaskDTO.from(task)
+                                };
+                                this._taskService.run(task).then(summary => {
+                                    if ((summary?.exitCode === undefined) || (summary.exitCode !== 0)) {
+                                        this._proxy.$OnDidEndTask(result);
+                                    }
+                                }, reason => {
+                                });
+                                resolve(result);
+                            }
+                        }, (_error) => {
+                            reject(( (new Error('Task not found'))));
+                        });
+                    }
+                    else {
+                        reject(( (new Error('No workspace folder'))));
+                    }
                 }
                 else {
-                    reject(( new Error('No workspace folder')));
+                    const task = TaskDTO.to(value, this._workspaceContextServer, true);
+                    this._taskService.run(task).then(undefined, reason => {
+                    });
+                    const result = {
+                        id: task._id,
+                        task: TaskDTO.from(task)
+                    };
+                    resolve(result);
                 }
-            }
-            else {
-                const task = TaskDTO.to(value, this._workspaceContextServer, true);
-                this._taskService.run(task).then(undefined, reason => {
-                });
-                const result = {
-                    id: task._id,
-                    task: TaskDTO.from(task)
-                };
-                resolve(result);
-            }
-        }));
+            }))
+        );
     }
     $customExecutionComplete(id, result) {
-        return ( new Promise((resolve, reject) => {
-            this._taskService.getActiveTasks().then((tasks) => {
-                for (const task of tasks) {
-                    if (id === task._id) {
-                        this._taskService.extensionCallbackTaskComplete(task, result).then((value) => {
-                            resolve(undefined);
-                        }, (error) => {
-                            reject(error);
-                        });
-                        return;
+        return (
+             (new Promise((resolve, reject) => {
+                this._taskService.getActiveTasks().then((tasks) => {
+                    for (const task of tasks) {
+                        if (id === task._id) {
+                            this._taskService.extensionCallbackTaskComplete(task, result).then((value) => {
+                                resolve(undefined);
+                            }, (error) => {
+                                reject(error);
+                            });
+                            return;
+                        }
                     }
-                }
-                reject(( new Error('Task to mark as complete not found')));
-            });
-        }));
+                    reject(( (new Error('Task to mark as complete not found'))));
+                });
+            }))
+        );
     }
     $terminateTask(id) {
-        return ( new Promise((resolve, reject) => {
-            this._taskService.getActiveTasks().then((tasks) => {
-                for (const task of tasks) {
-                    if (id === task._id) {
-                        this._taskService.terminate(task).then((value) => {
-                            resolve(undefined);
-                        }, (error) => {
-                            reject(undefined);
-                        });
-                        return;
+        return (
+             (new Promise((resolve, reject) => {
+                this._taskService.getActiveTasks().then((tasks) => {
+                    for (const task of tasks) {
+                        if (id === task._id) {
+                            this._taskService.terminate(task).then((value) => {
+                                resolve(undefined);
+                            }, (error) => {
+                                reject(undefined);
+                            });
+                            return;
+                        }
                     }
-                }
-                reject(( new ErrorNoTelemetry('Task to terminate not found')));
-            });
-        }));
+                    reject(( (new ErrorNoTelemetry('Task to terminate not found'))));
+                });
+            }))
+        );
     }
     $registerTaskSystem(key, info) {
         let platform$1;
@@ -673,43 +689,47 @@ let MainThreadTask = class MainThreadTask {
         this._taskService.registerTaskSystem(key, {
             platform: platform$1,
             uriProvider: (path) => {
-                return ( URI.from({ scheme: info.scheme, authority: info.authority, path }));
+                return (
+                     (URI.from({ scheme: info.scheme, authority: info.authority, path }))
+                );
             },
             context: this._extHostContext,
             resolveVariables: (workspaceFolder, toResolve, target) => {
                 const vars = [];
                 toResolve.variables.forEach(item => vars.push(item));
                 return Promise.resolve(this._proxy.$resolveVariables(workspaceFolder.uri, { process: toResolve.process, variables: vars })).then(values => {
-                    const partiallyResolvedVars = Array.from(( Object.values(values.variables)));
-                    return ( new Promise((resolve, reject) => {
-                        this._configurationResolverService.resolveWithInteraction(workspaceFolder, partiallyResolvedVars, 'tasks', undefined, target).then(resolvedVars => {
-                            if (!resolvedVars) {
-                                resolve(undefined);
-                            }
-                            const result = {
-                                process: undefined,
-                                variables: ( new Map())
-                            };
-                            for (let i = 0; i < partiallyResolvedVars.length; i++) {
-                                const variableName = vars[i].substring(2, vars[i].length - 1);
-                                if (resolvedVars && values.variables[vars[i]] === vars[i]) {
-                                    const resolved = resolvedVars.get(variableName);
-                                    if (typeof resolved === 'string') {
-                                        result.variables.set(variableName, resolved);
+                    const partiallyResolvedVars = Array.from(( (Object.values(values.variables))));
+                    return (
+                         (new Promise((resolve, reject) => {
+                            this._configurationResolverService.resolveWithInteraction(workspaceFolder, partiallyResolvedVars, 'tasks', undefined, target).then(resolvedVars => {
+                                if (!resolvedVars) {
+                                    resolve(undefined);
+                                }
+                                const result = {
+                                    process: undefined,
+                                    variables: ( (new Map()))
+                                };
+                                for (let i = 0; i < partiallyResolvedVars.length; i++) {
+                                    const variableName = vars[i].substring(2, vars[i].length - 1);
+                                    if (resolvedVars && values.variables[vars[i]] === vars[i]) {
+                                        const resolved = resolvedVars.get(variableName);
+                                        if (typeof resolved === 'string') {
+                                            result.variables.set(variableName, resolved);
+                                        }
+                                    }
+                                    else {
+                                        result.variables.set(variableName, partiallyResolvedVars[i]);
                                     }
                                 }
-                                else {
-                                    result.variables.set(variableName, partiallyResolvedVars[i]);
+                                if (isString(values.process)) {
+                                    result.process = values.process;
                                 }
-                            }
-                            if (isString(values.process)) {
-                                result.process = values.process;
-                            }
-                            resolve(result);
-                        }, reason => {
-                            reject(reason);
-                        });
-                    }));
+                                resolve(result);
+                            }, reason => {
+                                reject(reason);
+                            });
+                        }))
+                    );
                 });
             },
             findExecutable: (command, cwd, paths) => {
@@ -723,9 +743,9 @@ let MainThreadTask = class MainThreadTask {
 };
 MainThreadTask = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTask),
-    ( __param(1, ITaskService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IConfigurationResolverService))
+    ( (__param(1, ITaskService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IConfigurationResolverService)))
 ], MainThreadTask);
 
 export { MainThreadTask };

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

@@ -1,21 +1,29 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { ITerminalService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { TerminalShellExecutionCommandLineConfidence } from 'vscode/vscode/vs/workbench/api/common/extHostTypes';
 
 let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegration extends Disposable {
     constructor(extHostContext, _terminalService, workbenchEnvironmentService) {
         super();
         this._terminalService = _terminalService;
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTerminalShellIntegration));
-        const onDidAddCommandDetection = this._terminalService.createOnInstanceEvent(instance => {
+        const instanceDataListeners = ( new Map());
+        this._register(toDisposable(() => {
+            for (const listener of ( instanceDataListeners.values())) {
+                listener.dispose();
+            }
+        }));
+        const onDidAddCommandDetection = this._store.add(this._terminalService.createOnInstanceEvent(instance => {
             return ( Event.map(Event.filter(instance.capabilities.onDidAddCapabilityType, e => {
                 return e === 2 ;
-            }, this._store), () => instance));
-        });
+            }), () => instance));
+        })).event;
         this._store.add(onDidAddCommandDetection(e => this._proxy.$shellIntegrationChange(e.instanceId)));
         const commandDetectionStartEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(2 , e => e.onCommandExecuted));
         let currentCommand;
@@ -24,28 +32,48 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
                 return;
             }
             currentCommand = e.data;
-            this._proxy.$shellExecutionStart(e.instance.instanceId, e.data.command, e.data.cwd);
+            const instanceId = e.instance.instanceId;
+            this._proxy.$shellExecutionStart(instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, this._convertCwdToUri(e.data.cwd));
+            instanceDataListeners.get(instanceId)?.dispose();
+            instanceDataListeners.set(instanceId, Event.accumulate(e.instance.onData, 50, this._store)(events => this._proxy.$shellExecutionData(instanceId, events.join())));
         }));
         const commandDetectionEndEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(2 , e => e.onCommandFinished));
         this._store.add(commandDetectionEndEvent.event(e => {
             currentCommand = undefined;
-            this._proxy.$shellExecutionEnd(e.instance.instanceId, e.data.command, e.data.exitCode);
+            const instanceId = e.instance.instanceId;
+            instanceDataListeners.get(instanceId)?.dispose();
+            setTimeout(() => {
+                this._proxy.$shellExecutionEnd(instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, e.data.exitCode);
+            });
         }));
         const cwdChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(0 , e => e.onDidChangeCwd));
-        this._store.add(cwdChangeEvent.event(e => this._proxy.$cwdChange(e.instance.instanceId, e.data)));
+        this._store.add(cwdChangeEvent.event(e => {
+            this._proxy.$cwdChange(e.instance.instanceId, this._convertCwdToUri(e.data));
+        }));
         this._store.add(this._terminalService.onDidDisposeInstance(e => this._proxy.$closeTerminal(e.instanceId)));
-        if (!workbenchEnvironmentService.remoteAuthority) {
-            this._store.add(this._terminalService.onAnyInstanceData(e => this._proxy.$shellExecutionData(e.instance.instanceId, e.data)));
-        }
     }
     $executeCommand(terminalId, commandLine) {
         this._terminalService.getInstanceFromId(terminalId)?.runCommand(commandLine, true);
     }
+    _convertCwdToUri(cwd) {
+        return cwd ? URI.file(cwd) : undefined;
+    }
 };
 MainThreadTerminalShellIntegration = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTerminalShellIntegration),
     ( __param(1, ITerminalService)),
     ( __param(2, IWorkbenchEnvironmentService))
 ], MainThreadTerminalShellIntegration);
+function convertToExtHostCommandLineConfidence(command) {
+    switch (command.commandLineConfidence) {
+        case 'high':
+            return TerminalShellExecutionCommandLineConfidence.High;
+        case 'medium':
+            return TerminalShellExecutionCommandLineConfidence.Medium;
+        case 'low':
+        default:
+            return TerminalShellExecutionCommandLineConfidence.Low;
+    }
+}
 
 export { MainThreadTerminalShellIntegration };