Implement integrated terminal extension API

src/vs/vscode.d.ts

@@ -2971,6 +2971,37 @@ declare namespace vscode {
 		dispose(): void;
 	}
 
+	/**
+	 * An individual terminal instance within the integrated terminal.
+	 */
+	export interface Terminal {
+
+		/**
+		 * Send text to the terminal.
+		 *
+		 * @param addNewLine Whether to add a new line to the text being sent, this is normally
+		 * required to run a command in the terminal. This defaults to `true`.
+		 */
+		sendText(text: string, addNewLine?: boolean);
+
+		/**
+		 * Reveal this channel in the UI.
+		 *
+		 * @param preserveFocus When `true` the channel will not take focus.
+		 */
+		show(preservceFocus?: boolean): void;
+
+		/**
+		 * Hide this channel from the UI.
+		 */
+		hide(): void;
+
+		/**
+		 * Dispose and free associated resources.
+		 */
+		dispose(): void;
+	}
+
 	/**
 	 * Represents an extension.
 	 *
@@ -3429,6 +3460,15 @@ declare namespace vscode {
 		 * @return A new status bar item.
 		 */
 		export function createStatusBarItem(alignment?: StatusBarAlignment, priority?: number): StatusBarItem;
+
+		/**
+		 * Creates a [Terminal](#Terminal).
+		 *
+		 * @param name The optional name of a terminal, this will override the label used in the
+		 * terminal dropdown.
+		 * @return A new Terminal.
+		 */
+		export function createTerminal(name?: string): Thenable<vscode.Terminal>;
 	}
 
 	/**

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -18,6 +18,7 @@ import {ExtHostQuickOpen} from 'vs/workbench/api/node/extHostQuickOpen';
 import {ExtHostStatusBar} from 'vs/workbench/api/node/extHostStatusBar';
 import {ExtHostCommands} from 'vs/workbench/api/node/extHostCommands';
 import {ExtHostOutputService} from 'vs/workbench/api/node/extHostOutputService';
+import {ExtHostTerminalService} from 'vs/workbench/api/node/extHostTerminalService';
 import {ExtHostMessageService} from 'vs/workbench/api/node/extHostMessageService';
 import {ExtHostEditors} from 'vs/workbench/api/node/extHostEditors';
 import {ExtHostLanguages} from 'vs/workbench/api/node/extHostLanguages';
@@ -117,6 +118,7 @@ export class ExtHostAPIImplementation {
 		const extHostMessageService = new ExtHostMessageService(threadService);
 		const extHostStatusBar = new ExtHostStatusBar(threadService);
 		const extHostOutputService = new ExtHostOutputService(threadService);
+		const extHostTerminalService = new ExtHostTerminalService(threadService);
 		const workspacePath = contextService.getWorkspace() ? contextService.getWorkspace().resource.fsPath : undefined;
 		const extHostWorkspace = new ExtHostWorkspace(threadService, workspacePath);
 		const languages = new ExtHostLanguages(threadService);
@@ -253,6 +255,9 @@ export class ExtHostAPIImplementation {
 			},
 			createOutputChannel(name: string): vscode.OutputChannel {
 				return extHostOutputService.createOutputChannel(name);
+			},
+			createTerminal(name?: string): Thenable<vscode.Terminal> {
+				return extHostTerminalService.createTerminal(name);
 			}
 		};
 

src/vs/workbench/api/node/extHost.contribution.ts

@@ -28,6 +28,7 @@ import {MainThreadQuickOpen} from './mainThreadQuickOpen';
 import {MainThreadStatusBar} from './mainThreadStatusBar';
 import {MainThreadStorage} from './mainThreadStorage';
 import {MainThreadTelemetry} from './mainThreadTelemetry';
+import {MainThreadTerminalService} from './mainThreadTerminalService';
 import {MainThreadWorkspace} from './mainThreadWorkspace';
 import {MainProcessExtensionService} from './mainThreadExtensionService';
 import {MainThreadFileSystemEventService} from './mainThreadFileSystemEventService';
@@ -72,6 +73,7 @@ export class ExtHostContribution implements IWorkbenchContribution {
 		col.define(MainContext.MainThreadStatusBar).set(create(MainThreadStatusBar));
 		col.define(MainContext.MainThreadStorage).set(create(MainThreadStorage));
 		col.define(MainContext.MainThreadTelemetry).set(create(MainThreadTelemetry));
+		col.define(MainContext.MainThreadTerminalService).set(create(MainThreadTerminalService));
 		col.define(MainContext.MainThreadWorkspace).set(create(MainThreadWorkspace));
 		if (this.extensionService instanceof MainProcessExtensionService) {
 			col.define(MainContext.MainProcessExtensionService).set(<MainProcessExtensionService>this.extensionService);

src/vs/workbench/api/node/extHost.protocol.ts

@@ -146,6 +146,14 @@ export abstract class MainThreadOutputServiceShape {
 	$close(channelId: string): TPromise<void> { throw ni(); }
 }
 
+export abstract class MainThreadTerminalServiceShape {
+	$createTerminal(name?: string): TPromise<number> { throw ni(); }
+	$dispose(terminalId: number): void { throw ni(); }
+	$hide(terminalId: number): void { throw ni(); }
+	$sendText(terminalId: number, text: string, addNewLine: boolean): void { throw ni(); }
+	$show(terminalId: number, preserveFocus: boolean): void { throw ni(); }
+}
+
 export interface MyQuickPickItems extends IPickOpenEntry {
 	handle: number;
 }
@@ -294,6 +302,7 @@ export const MainContext = {
 	MainThreadStatusBar: createMainId<MainThreadStatusBarShape>('MainThreadStatusBar', MainThreadStatusBarShape),
 	MainThreadStorage: createMainId<MainThreadStorageShape>('MainThreadStorage', MainThreadStorageShape),
 	MainThreadTelemetry: createMainId<MainThreadTelemetryShape>('MainThreadTelemetry', MainThreadTelemetryShape),
+	MainThreadTerminalService: createMainId<MainThreadTerminalServiceShape>('MainThreadTerminalService', MainThreadTerminalServiceShape),
 	MainThreadWorkspace: createMainId<MainThreadWorkspaceShape>('MainThreadWorkspace', MainThreadWorkspaceShape),
 	MainProcessExtensionService: createMainId<MainProcessExtensionServiceShape>('MainProcessExtensionService', MainProcessExtensionServiceShape),
 };

src/vs/workbench/api/node/extHostTerminalService.ts

@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {TPromise} from 'vs/base/common/winjs.base';
+import {IThreadService} from 'vs/workbench/services/thread/common/threadService';
+import vscode = require('vscode');
+import {MainContext, MainThreadTerminalServiceShape} from './extHost.protocol';
+
+export class ExtHostTerminal implements vscode.Terminal {
+
+	private _id: number;
+	private _proxy: MainThreadTerminalServiceShape;
+	private _disposed: boolean;
+
+	constructor(proxy: MainThreadTerminalServiceShape, id: number) {
+		this._id = id;
+		this._proxy = proxy;
+	}
+
+	public sendText(text: string, addNewLine: boolean = true) {
+		this._proxy.$sendText(this._id, text, addNewLine);
+	}
+
+	public show(preserveFocus: boolean): void {
+		this._proxy.$show(this._id, preserveFocus);
+	}
+
+	public hide(): void {
+		this._proxy.$hide(this._id);
+	}
+
+	public dispose(): void {
+		if (!this._disposed) {
+			this._disposed = true;
+			this._proxy.$dispose(this._id);
+		}
+	}
+}
+
+export class ExtHostTerminalService {
+
+	private _proxy: MainThreadTerminalServiceShape;
+
+	constructor(threadService: IThreadService) {
+		this._proxy = threadService.get(MainContext.MainThreadTerminalService);
+	}
+
+	public createTerminal(name?: string): TPromise<vscode.Terminal> {
+		return this._proxy.$createTerminal(name).then((terminalId) => {
+			return new ExtHostTerminal(this._proxy, terminalId);
+		});
+	}
+}

src/vs/workbench/api/node/mainThreadTerminalService.ts

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {TPromise} from 'vs/base/common/winjs.base';
+import {ITerminalService} from 'vs/workbench/parts/terminal/electron-browser/terminal';
+import {MainThreadTerminalServiceShape} from './extHost.protocol';
+
+export class MainThreadTerminalService extends MainThreadTerminalServiceShape {
+
+	private _terminalService: ITerminalService;
+
+	constructor(
+		@ITerminalService terminalService: ITerminalService
+	) {
+		super();
+		this._terminalService = terminalService;
+	}
+
+	public $createTerminal(name?: string): TPromise<number> {
+		return this._terminalService.createNew(name);
+	}
+
+	public $show(terminalId: number, preserveFocus: boolean): void {
+		this._terminalService.show(!preserveFocus).then((terminalPanel) => {
+			terminalPanel.setActiveTerminalById(terminalId);
+		});
+	}
+
+	public $hide(terminalId: number): void {
+		this._terminalService.hide();
+	}
+
+	public $dispose(terminalId: number): void {
+		// TODO: This could be improved by not first showing the terminal to be disposed
+		var self = this;
+		this._terminalService.show(false).then((terminalPanel) => {
+			terminalPanel.setActiveTerminalById(terminalId);
+			self._terminalService.close();
+		});;
+	}
+
+	public $sendText(terminalId: number, text: string, addNewLine: boolean): void {
+		this._terminalService.show(false).then((terminalPanel) => {
+			terminalPanel.setActiveTerminalById(terminalId);
+			terminalPanel.sendTextToActiveTerminal(text, addNewLine);
+		});
+	}
+}

src/vs/workbench/parts/terminal/electron-browser/terminal.ts

@@ -65,15 +65,15 @@ export interface ITerminalService {
 
 	close(): TPromise<any>;
 	copySelection(): TPromise<any>;
-	createNew(): TPromise<any>;
-	focus(): TPromise<any>;
+	createNew(name?: string): TPromise<number>;
 	focusNext(): TPromise<any>;
 	focusPrevious(): TPromise<any>;
 	hide(): TPromise<any>;
 	paste(): TPromise<any>;
 	runSelectedText(): TPromise<any>;
 	scrollDown(): TPromise<any>;
 	scrollUp(): TPromise<any>;
+	show(focus: boolean): TPromise<ITerminalPanel>;
 	setActiveTerminal(index: number): TPromise<any>;
 	toggle(): TPromise<any>;
 
@@ -82,3 +82,8 @@ export interface ITerminalService {
 	initConfigHelper(panelContainer: Builder): void;
 	killTerminalProcess(terminalProcess: ITerminalProcess): void;
 }
+
+export interface ITerminalPanel {
+	sendTextToActiveTerminal(text: string, addNewLine: boolean): void;
+	setActiveTerminalById(terminalId: number): void;
+}

src/vs/workbench/parts/terminal/electron-browser/terminalActions.ts

@@ -98,7 +98,7 @@ export class FocusTerminalAction extends Action {
 	}
 
 	public run(event?: any): TPromise<any> {
-		return this.terminalService.focus();
+		return this.terminalService.show(true);
 	}
 }
 

src/vs/workbench/parts/terminal/electron-browser/terminalInstance.ts

@@ -23,6 +23,8 @@ import {TabFocus} from 'vs/editor/common/config/commonEditorConfig';
 
 export class TerminalInstance {
 
+	public id: number;
+
 	private static eolRegex = /\r?\n/g;
 
 	private isExiting: boolean = false;
@@ -53,6 +55,7 @@ export class TerminalInstance {
 		this.terminalDomElement = document.createElement('div');
 		this.xterm = xterm();
 
+		this.id = this.terminalProcess.process.pid;
 		this.terminalProcess.process.on('message', (message) => {
 			if (message.type === 'data') {
 				this.xterm.write(message.content);
@@ -63,6 +66,8 @@ export class TerminalInstance {
 				event: 'input',
 				data: this.sanitizeInput(data)
 			});
+
+			console.log('this.terminalProcess.process.pid=' + this.terminalProcess.process.pid);
 			return false;
 		});
 		this.xterm.attachCustomKeydownHandler(function (event: KeyboardEvent) {
@@ -176,6 +181,16 @@ export class TerminalInstance {
 		});
 	}
 
+	public sendText(text: string, addNewLine: boolean): void {;
+		if (addNewLine && text.substr(text.length - os.EOL.length) !== os.EOL) {
+			text += os.EOL;
+		}
+		this.terminalProcess.process.send({
+			event: 'input',
+			data: text
+		});
+	}
+
 	public focus(force?: boolean): void {
 		if (!this.xterm) {
 			return;

src/vs/workbench/parts/terminal/electron-browser/terminalPanel.ts

@@ -104,7 +104,7 @@ export class TerminalPanel extends Panel {
 		return super.getActionItem(action);
 	}
 
-	public create(parent: Builder): TPromise<void> {
+	public create(parent: Builder): TPromise<any> {
 		super.create(parent);
 		this.parentDomElement = parent.getHTMLElement();
 		this.terminalService.initConfigHelper(parent);
@@ -174,10 +174,11 @@ export class TerminalPanel extends Panel {
 		}));
 	}
 
-	public createNewTerminalInstance(terminalProcess: ITerminalProcess, terminalFocusContextKey: IContextKey<boolean>): TPromise<void> {
-		return this.createTerminal(terminalProcess, terminalFocusContextKey).then(() => {
+	public createNewTerminalInstance(process: ITerminalProcess, focusContextKey: IContextKey<boolean>): TPromise<number> {
+		return this.createTerminal(process, focusContextKey).then((terminalInstance) => {
 			this.updateConfig();
 			this.focus();
+			return TPromise.as(terminalInstance.id);
 		});
 	}
 
@@ -206,6 +207,11 @@ export class TerminalPanel extends Panel {
 		return super.setVisible(visible);
 	}
 
+	public sendTextToActiveTerminal(text: string, addNewLine: boolean): void {
+		let terminalInstance = this.terminalInstances[this.terminalService.getActiveTerminalIndex()];
+		terminalInstance.sendText(text, addNewLine);
+	}
+
 	private createTerminal(terminalProcess: ITerminalProcess, terminalFocusContextKey: IContextKey<boolean>): TPromise<TerminalInstance> {
 		return new TPromise<TerminalInstance>(resolve => {
 			var terminalInstance = new TerminalInstance(
@@ -229,12 +235,24 @@ export class TerminalPanel extends Panel {
 		});
 	}
 
-	public setActiveTerminal(newActiveIndex: number) {
+	public setActiveTerminal(newActiveIndex: number): void {
 		this.terminalInstances.forEach((terminalInstance, i) => {
 			terminalInstance.toggleVisibility(i === newActiveIndex);
 		});
 	}
 
+	public setActiveTerminalById(terminalId: number): void {
+		let terminalIndex = -1;
+		this.terminalInstances.forEach((terminalInstance, i) => {
+			if (terminalInstance.id === terminalId) {
+				terminalIndex = i;
+			}
+		});
+		if (terminalIndex !== -1) {
+			this.setActiveTerminal(terminalIndex);
+		}
+	}
+
 	private onTerminalInstanceExit(terminalInstance: TerminalInstance): void {
 		let index = this.terminalInstances.indexOf(terminalInstance);
 		if (index !== -1) {
@@ -247,7 +265,7 @@ export class TerminalPanel extends Panel {
 		if (this.terminalInstances.length === 0) {
 			this.terminalService.hide();
 		} else {
-			this.terminalService.focus();
+			this.terminalService.show(true);
 		}
 	}