@codingame/monaco-vscode-api 15.0.3 → 16.0.0

package/vscode/src/vs/workbench/api/common/extHostMcp.d.ts

@@ -0,0 +1,23 @@
+import * as vscode from "vscode";
+import { Disposable, IDisposable } from "../../../base/common/lifecycle.js";
+import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+import { McpServerLaunch } from "../../contrib/mcp/common/mcpTypes.js";
+import { ExtHostMcpShape, MainThreadMcpShape } from "./extHost.protocol.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+export declare const IExtHostMpcService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostMpcService>;
+export interface IExtHostMpcService extends ExtHostMcpShape {
+    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpConfigurationProvider): IDisposable;
+}
+export declare class ExtHostMcpService extends Disposable implements IExtHostMpcService {
+    protected _proxy: MainThreadMcpShape;
+    private readonly _initialProviderPromises;
+    private readonly _sseEventSources;
+    private readonly _eventSource;
+    constructor(extHostRpc: IExtHostRpcService);
+    $startMcp(id: number, launch: McpServerLaunch.Serialized): void;
+    protected _startMcp(id: number, launch: McpServerLaunch): void;
+    $stopMcp(id: number): void;
+    $sendMessage(id: number, message: string): void;
+    $waitForInitialCollectionProviders(): Promise<void>;
+    registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpConfigurationProvider): IDisposable;
+}

package/vscode/src/vs/workbench/api/common/extHostMcp.js

@@ -0,0 +1,193 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { importAMDNodeModule } from '../../../amdX.js';
+import { Sequencer, DeferredPromise } from '../../../base/common/async.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Lazy } from '../../../base/common/lazy.js';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { StorageScope } from '../../../platform/storage/common/storage.js';
+import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionPrefixedIdentifier } from '../../contrib/mcp/common/mcpTypes.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { LogLevel } from '../../../platform/log/common/log.js';
+
+const IExtHostMpcService = ( createDecorator('IExtHostMpcService'));
+let ExtHostMcpService = class ExtHostMcpService extends Disposable {
+    constructor(extHostRpc) {
+        super();
+        this._initialProviderPromises = ( new Set());
+        this._sseEventSources = this._register(( new DisposableMap()));
+        this._eventSource = ( new Lazy(async () => {
+            const es = await importAMDNodeModule('@c4312/eventsource-umd', 'dist/index.umd.js');
+            return es.EventSource;
+        }));
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadMcp));
+    }
+    $startMcp(id, launch) {
+        this._startMcp(id, McpServerLaunch.fromSerialized(launch));
+    }
+    _startMcp(id, launch) {
+        if (launch.type === McpServerTransportType.SSE) {
+            this._sseEventSources.set(id, ( new McpSSEHandle(this._eventSource.value, id, launch, this._proxy)));
+            return;
+        }
+        throw ( new Error('not implemented'));
+    }
+    $stopMcp(id) {
+        if (( this._sseEventSources.has(id))) {
+            this._sseEventSources.deleteAndDispose(id);
+            this._proxy.$onDidChangeState(id, { state: McpConnectionState.Kind.Stopped });
+        }
+    }
+    $sendMessage(id, message) {
+        this._sseEventSources.get(id)?.send(message);
+    }
+    async $waitForInitialCollectionProviders() {
+        await Promise.all(this._initialProviderPromises);
+    }
+    registerMcpConfigurationProvider(extension, id, provider) {
+        const store = ( new DisposableStore());
+        const metadata = extension.contributes?.modelContextServerCollections?.find(m => m.id === id);
+        if (!metadata) {
+            throw ( new Error(
+                `MCP configuration providers must be registered in the contributes.modelContextServerCollections array within your package.json, but "${id}" was not`
+            ));
+        }
+        const mcp = {
+            id: extensionPrefixedIdentifier(extension.identifier, id),
+            isTrustedByDefault: true,
+            label: metadata?.label ?? extension.displayName ?? extension.name,
+            scope: StorageScope.WORKSPACE
+        };
+        const update = async () => {
+            const list = await provider.provideMcpServerDefinitions(CancellationToken.None);
+            function isSSEConfig(candidate) {
+                return !!candidate.uri;
+            }
+            const servers = [];
+            for (const item of list ?? []) {
+                servers.push({
+                    id: ExtensionIdentifier.toKey(extension.identifier),
+                    label: item.label,
+                    launch: isSSEConfig(item)
+                        ? {
+                            type: McpServerTransportType.SSE,
+                            uri: item.uri,
+                            headers: item.headers,
+                        }
+                        : {
+                            type: McpServerTransportType.Stdio,
+                            cwd: item.cwd,
+                            args: item.args,
+                            command: item.command,
+                            env: item.env,
+                            envFile: undefined,
+                        }
+                });
+            }
+            this._proxy.$upsertMcpCollection(mcp, servers);
+        };
+        store.add(toDisposable(() => {
+            this._proxy.$deleteMcpCollection(mcp.id);
+        }));
+        if (provider.onDidChange) {
+            store.add(provider.onDidChange(update));
+        }
+        const promise = ( new Promise(resolve => {
+            setTimeout(() => update().finally(() => {
+                this._initialProviderPromises.delete(promise);
+                resolve();
+            }), 0);
+        }));
+        this._initialProviderPromises.add(promise);
+        return store;
+    }
+};
+ExtHostMcpService = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostMcpService));
+class McpSSEHandle extends Disposable {
+    constructor(eventSourceCtor, _id, launch, _proxy) {
+        super();
+        this._id = _id;
+        this._proxy = _proxy;
+        this._requestSequencer = ( new Sequencer());
+        this._postEndpoint = ( new DeferredPromise());
+        eventSourceCtor.then(EventSourceCtor => this._attach(EventSourceCtor, launch));
+    }
+    _attach(EventSourceCtor, launch) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const eventSource = ( new EventSourceCtor(( launch.uri.toString()), {
+            fetch: (input, init) => fetch(input, {
+                ...init,
+                headers: {
+                    ...Object.fromEntries(launch.headers),
+                    ...init?.headers,
+                },
+            }).then(async (res) => {
+                if (res.status >= 300) {
+                    this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `${res.status} status connecting to ${launch.uri}: ${await this._getErrText(res)}` });
+                    eventSource.close();
+                }
+                return res;
+            }, err => {
+                this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `Error connecting to ${launch.uri}: ${String(err)}` });
+                eventSource.close();
+                return Promise.reject(err);
+            })
+        }));
+        this._register(toDisposable(() => eventSource.close()));
+        eventSource.addEventListener('endpoint', e => {
+            this._postEndpoint.complete(( ( new URL(e.data, ( launch.uri.toString()))).toString()));
+        });
+        eventSource.addEventListener('message', e => {
+            this._proxy.$onDidReceiveMessage(this._id, e.data);
+        });
+        eventSource.addEventListener('open', () => {
+            this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Running });
+        });
+        eventSource.addEventListener('error', (err) => {
+            this._postEndpoint.cancel();
+            this._proxy.$onDidChangeState(this._id, {
+                state: McpConnectionState.Kind.Error,
+                message: `Error connecting to ${launch.uri}: ${err.code || 0} ${err.message || JSON.stringify(err)}`,
+            });
+            eventSource.close();
+        });
+    }
+    async send(message) {
+        try {
+            const res = await this._requestSequencer.queue(async () => {
+                const endpoint = await this._postEndpoint.p;
+                const asBytes = ( new TextEncoder()).encode(message);
+                return fetch(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': String(asBytes.length),
+                    },
+                    body: asBytes,
+                });
+            });
+            if (res.status >= 300) {
+                this._proxy.$onDidPublishLog(this._id, LogLevel.Warning, `${res.status} status sending message to ${this._postEndpoint}: ${await this._getErrText(res)}`);
+            }
+        }
+        catch (err) {
+        }
+    }
+    async _getErrText(res) {
+        try {
+            return await res.text();
+        }
+        catch {
+            return res.statusText;
+        }
+    }
+}
+
+export { ExtHostMcpService, IExtHostMpcService };

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -260,7 +260,7 @@ class ExtHostNotebookController {
             throw ( new Error('Document version mismatch'));
         }
         if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-            throw new FileOperationError(( localize(2506, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+            throw new FileOperationError(( localize(2546, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
         }
         const data = {
             metadata: filter(document.apiNotebook.metadata, key => !(serializer.options?.transientDocumentMetadata ?? {})[key]),
@@ -432,7 +432,7 @@ class ExtHostNotebookController {
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(( localize(2507, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2547, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

package/vscode/src/vs/workbench/api/common/extHostStatusBar.js

@@ -188,7 +188,7 @@ class ExtHostStatusBarEntry {
             }
             else {
                 name = ( localize(
-                    2508,
+                    2548,
                     "{0} (Extension)",
                     this._extension.displayName || this._extension.name
                 ));
@@ -221,7 +221,7 @@ class StatusBarMessage {
     constructor(statusBar) {
         this._messages = [];
         this._item = statusBar.createStatusBarEntry(undefined, 'status.extensionMessage', StatusBarAlignment.Left, Number.MIN_VALUE);
-        this._item.name = ( localize(2509, "Extension Status"));
+        this._item.name = ( localize(2549, "Extension Status"));
     }
     dispose() {
         this._messages.length = 0;

package/vscode/src/vs/workbench/api/common/extHostTask.d.ts

@@ -4,7 +4,7 @@ import { MainThreadTaskShape, ExtHostTaskShape } from "./extHost.protocol.js";
 import * as types from "./extHostTypes.js";
 import { IExtHostWorkspaceProvider, IExtHostWorkspace } from "./extHostWorkspace.js";
 import type * as vscode from "vscode";
-import * as tasks from "./shared/tasks.js";
+import * as tasks from "@codingame/monaco-vscode-extensions-service-override/vscode/vs/workbench/api/common/shared/tasks";
 import { IExtHostDocumentsAndEditors } from "./extHostDocumentsAndEditors.js";
 import { IExtHostConfiguration } from "./extHostConfiguration.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
@@ -13,6 +13,7 @@ import { IExtHostRpcService } from "./extHostRpcService.js";
 import { IExtHostInitDataService } from "./extHostInitDataService.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
 import { IExtHostApiDeprecationService } from "./extHostApiDeprecationService.js";
+import { ITaskProblemMatcherStartedDto, ITaskProblemMatcherEndedDto } from "@codingame/monaco-vscode-extensions-service-override/vscode/vs/workbench/api/common/shared/tasks";
 export interface IExtHostTask extends ExtHostTaskShape {
     readonly _serviceBrand: undefined;
     taskExecutions: vscode.TaskExecution[];
@@ -20,6 +21,8 @@ export interface IExtHostTask extends ExtHostTaskShape {
     onDidEndTask: Event<vscode.TaskEndEvent>;
     onDidStartTaskProcess: Event<vscode.TaskProcessStartEvent>;
     onDidEndTaskProcess: Event<vscode.TaskProcessEndEvent>;
+    onDidStartTaskProblemMatchers: Event<vscode.TaskProblemMatcherStartedEvent>;
+    onDidEndTaskProblemMatchers: Event<vscode.TaskProblemMatcherEndedEvent>;
     registerTaskProvider(extension: IExtensionDescription, type: string, provider: vscode.TaskProvider): vscode.Disposable;
     registerTaskSystem(scheme: string, info: tasks.ITaskSystemInfoDTO): void;
     fetchTasks(filter?: vscode.TaskFilter): Promise<vscode.Task[]>;
@@ -75,6 +78,8 @@ export declare abstract class ExtHostTaskBase implements ExtHostTaskShape, IExtH
     protected readonly _onDidTerminateTask: Emitter<vscode.TaskEndEvent>;
     protected readonly _onDidTaskProcessStarted: Emitter<vscode.TaskProcessStartEvent>;
     protected readonly _onDidTaskProcessEnded: Emitter<vscode.TaskProcessEndEvent>;
+    protected readonly _onDidStartTaskProblemMatchers: Emitter<vscode.TaskProblemMatcherStartedEvent>;
+    protected readonly _onDidEndTaskProblemMatchers: Emitter<vscode.TaskProblemMatcherEndedEvent>;
     constructor(extHostRpc: IExtHostRpcService, initData: IExtHostInitDataService, workspaceService: IExtHostWorkspace, editorService: IExtHostDocumentsAndEditors, configurationService: IExtHostConfiguration, extHostTerminalService: IExtHostTerminalService, logService: ILogService, deprecationService: IExtHostApiDeprecationService);
     registerTaskProvider(extension: IExtensionDescription, type: string, provider: vscode.TaskProvider): vscode.Disposable;
     registerTaskSystem(scheme: string, info: tasks.ITaskSystemInfoDTO): void;
@@ -90,6 +95,10 @@ export declare abstract class ExtHostTaskBase implements ExtHostTaskShape, IExtH
     $onDidStartTaskProcess(value: tasks.ITaskProcessStartedDTO): Promise<void>;
     get onDidEndTaskProcess(): Event<vscode.TaskProcessEndEvent>;
     $onDidEndTaskProcess(value: tasks.ITaskProcessEndedDTO): Promise<void>;
+    get onDidStartTaskProblemMatchers(): Event<vscode.TaskProblemMatcherStartedEvent>;
+    $onDidStartTaskProblemMatchers(value: ITaskProblemMatcherStartedDto): Promise<void>;
+    get onDidEndTaskProblemMatchers(): Event<vscode.TaskProblemMatcherEndedEvent>;
+    $onDidEndTaskProblemMatchers(value: ITaskProblemMatcherEndedDto): Promise<void>;
     protected abstract provideTasksInternal(validTypes: {
         [key: string]: boolean;
     }, taskIdPromises: Promise<void>[], handler: HandlerData, value: vscode.Task[] | null | undefined): {

package/vscode/src/vs/workbench/api/common/extHostTask.js

@@ -384,6 +384,8 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         this._onDidTerminateTask = ( new Emitter());
         this._onDidTaskProcessStarted = ( new Emitter());
         this._onDidTaskProcessEnded = ( new Emitter());
+        this._onDidStartTaskProblemMatchers = ( new Emitter());
+        this._onDidEndTaskProblemMatchers = ( new Emitter());
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTask));
         this._workspaceProvider = workspaceService;
         this._editorService = editorService;
@@ -487,6 +489,32 @@ let ExtHostTaskBase = class ExtHostTaskBase {
             exitCode: value.exitCode
         });
     }
+    get onDidStartTaskProblemMatchers() {
+        return this._onDidStartTaskProblemMatchers.event;
+    }
+    async $onDidStartTaskProblemMatchers(value) {
+        let execution;
+        try {
+            execution = await this.getTaskExecution(value.execution.id);
+        }
+        catch (error) {
+            return;
+        }
+        this._onDidStartTaskProblemMatchers.fire({ execution });
+    }
+    get onDidEndTaskProblemMatchers() {
+        return this._onDidEndTaskProblemMatchers.event;
+    }
+    async $onDidEndTaskProblemMatchers(value) {
+        let execution;
+        try {
+            execution = await this.getTaskExecution(value.execution.id);
+        }
+        catch (error) {
+            return;
+        }
+        this._onDidEndTaskProblemMatchers.fire({ execution, hasErrors: value.hasErrors });
+    }
     $provideTasks(handle, validTypes) {
         const handler = this._handlers.get(handle);
         if (!handler) {

package/vscode/src/vs/workbench/api/common/extHostTelemetry.js

@@ -28,7 +28,7 @@ let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
         const id = initData.remote.isRemote ? 'remoteExtHostTelemetry' : isWorker ? 'workerExtHostTelemetry' : 'extHostTelemetry';
         this._outputLogger = this._register(loggerService.createLogger(id, {
             name: ( localize(
-                2510,
+                2550,
                 "Extension Telemetry{0}",
                 this._inLoggingOnlyMode ? ' (Not Sent)' : ''
             )),

package/vscode/src/vs/workbench/api/common/extHostTerminalService.js

@@ -6,13 +6,13 @@ import { createDecorator } from '../../../platform/instantiation/common/instanti
 import { URI } from '../../../base/common/uri.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { Disposable, MutableDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { TerminalShellType, Disposable as Disposable$1, EnvironmentVariableMutatorType } from './extHostTypes.js';
+import { Disposable as Disposable$1, EnvironmentVariableMutatorType } from './extHostTypes.js';
 import { localize } from '../../../nls.js';
 import { NotSupportedError } from '../../../base/common/errors.js';
 import { serializeEnvironmentVariableCollection, serializeEnvironmentDescriptionMap } from '../../../platform/terminal/common/environmentVariableShared.js';
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { generateUuid } from '../../../base/common/uuid.js';
-import { GeneralShellType, WindowsShellType, PosixShellType, ProcessPropertyType } from '../../../platform/terminal/common/terminal.js';
+import { ProcessPropertyType } from '../../../platform/terminal/common/terminal.js';
 import { TerminalDataBufferer } from '../../../platform/terminal/common/terminalDataBuffering.js';
 import { ThemeColor } from '../../../base/common/themables.js';
 import { Promises } from '../../../base/common/async.js';
@@ -29,7 +29,7 @@ class ExtHostTerminal extends Disposable {
         this._creationOptions = _creationOptions;
         this._name = _name;
         this._disposed = false;
-        this._state = { isInteractedWith: false, shellType: undefined };
+        this._state = { isInteractedWith: false, shell: undefined };
         this.isOpen = false;
         this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
@@ -176,52 +176,10 @@ class ExtHostTerminal extends Disposable {
         return false;
     }
     setShellType(shellType) {
-        let extHostType;
-        switch (shellType) {
-            case PosixShellType.Sh:
-                extHostType = TerminalShellType.Sh;
-                break;
-            case PosixShellType.Bash:
-                extHostType = TerminalShellType.Bash;
-                break;
-            case PosixShellType.Fish:
-                extHostType = TerminalShellType.Fish;
-                break;
-            case PosixShellType.Csh:
-                extHostType = TerminalShellType.Csh;
-                break;
-            case PosixShellType.Ksh:
-                extHostType = TerminalShellType.Ksh;
-                break;
-            case PosixShellType.Zsh:
-                extHostType = TerminalShellType.Zsh;
-                break;
-            case WindowsShellType.CommandPrompt:
-                extHostType = TerminalShellType.CommandPrompt;
-                break;
-            case WindowsShellType.GitBash:
-                extHostType = TerminalShellType.GitBash;
-                break;
-            case GeneralShellType.PowerShell:
-                extHostType = TerminalShellType.PowerShell;
-                break;
-            case GeneralShellType.Python:
-                extHostType = TerminalShellType.Python;
-                break;
-            case GeneralShellType.Julia:
-                extHostType = TerminalShellType.Julia;
-                break;
-            case GeneralShellType.NuShell:
-                extHostType = TerminalShellType.NuShell;
-                break;
-            default:
-                extHostType = undefined;
-                break;
-        }
-        if (this._state.shellType !== shellType) {
+        if (this._state.shell !== shellType) {
             this._state = {
                 ...this._state,
-                shellType: extHostType
+                shell: shellType
             };
             return true;
         }
@@ -524,7 +482,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     async $startExtensionTerminal(id, initialDimensions) {
         const terminal = this.getTerminalById(id);
         if (!terminal) {
-            return { message: ( localize(2511, "Could not find the terminal with id {0} on the extension host", id)) };
+            return { message: ( localize(2551, "Could not find the terminal with id {0} on the extension host", id)) };
         }
         if (!terminal.isOpen) {
             await ( new Promise(r => {

package/vscode/src/vs/workbench/api/common/extHostTerminalShellIntegration.d.ts

@@ -1,11 +1,11 @@
 import type * as vscode from "vscode";
 import { TerminalShellExecutionCommandLineConfidence } from "./extHostTypes.js";
-import { Disposable } from "../../../base/common/lifecycle.js";
+import { Disposable, DisposableStore } from "../../../base/common/lifecycle.js";
 import { type ExtHostTerminalShellIntegrationShape, type MainThreadTerminalShellIntegrationShape } from "./extHost.protocol.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
 import { IExtHostTerminalService } from "./extHostTerminalService.js";
 import { Emitter, type Event } from "../../../base/common/event.js";
-import { type UriComponents } from "../../../base/common/uri.js";
+import { URI, type UriComponents } from "../../../base/common/uri.js";
 export interface IExtHostTerminalShellIntegration extends ExtHostTerminalShellIntegrationShape {
     readonly _serviceBrand: undefined;
     readonly onDidChangeTerminalShellIntegration: Event<vscode.TerminalShellIntegrationChangeEvent>;
@@ -33,3 +33,45 @@ export declare class ExtHostTerminalShellIntegration extends Disposable implemen
     $cwdChange(instanceId: number, cwd: UriComponents | undefined): void;
     $closeTerminal(instanceId: number): void;
 }
+export declare class InternalTerminalShellIntegration extends Disposable {
+    private readonly _terminal;
+    private readonly _onDidStartTerminalShellExecution;
+    private _pendingExecutions;
+    private _pendingEndingExecution;
+    private _currentExecutionProperties;
+    private _currentExecution;
+    get currentExecution(): InternalTerminalShellExecution | undefined;
+    private _env;
+    private _cwd;
+    readonly store: DisposableStore;
+    readonly value: vscode.TerminalShellIntegration;
+    protected readonly _onDidRequestChangeShellIntegration: Emitter<vscode.TerminalShellIntegrationChangeEvent>;
+    readonly onDidRequestChangeShellIntegration: Event<vscode.TerminalShellIntegrationChangeEvent>;
+    protected readonly _onDidRequestShellExecution: Emitter<string>;
+    readonly onDidRequestShellExecution: Event<string>;
+    protected readonly _onDidRequestEndExecution: Emitter<vscode.TerminalShellExecutionEndEvent>;
+    readonly onDidRequestEndExecution: Event<vscode.TerminalShellExecutionEndEvent>;
+    protected readonly _onDidRequestNewExecution: Emitter<string>;
+    readonly onDidRequestNewExecution: Event<string>;
+    constructor(_terminal: vscode.Terminal, _onDidStartTerminalShellExecution: Emitter<vscode.TerminalShellExecutionStartEvent>);
+    requestNewShellExecution(commandLine: vscode.TerminalShellExecutionCommandLine, cwd: URI | undefined): InternalTerminalShellExecution;
+    startShellExecution(commandLine: vscode.TerminalShellExecutionCommandLine, cwd: URI | undefined): undefined;
+    emitData(data: string): void;
+    endShellExecution(commandLine: vscode.TerminalShellExecutionCommandLine | undefined, exitCode: number | undefined): void;
+    setEnv(keys: string[], values: string[], isTrusted: boolean): void;
+    setCwd(cwd: URI | undefined): void;
+    private _fireChangeEvent;
+}
+declare class InternalTerminalShellExecution {
+    private _commandLine;
+    readonly cwd: URI | undefined;
+    readonly value: vscode.TerminalShellExecution;
+    private _dataStream;
+    private _isEnded;
+    constructor(_commandLine: vscode.TerminalShellExecutionCommandLine, cwd: URI | undefined);
+    private _createDataStream;
+    emitData(data: string): void;
+    endExecution(commandLine: vscode.TerminalShellExecutionCommandLine | undefined): void;
+    flush(): Promise<void>;
+}
+export {};