Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/src/vs/platform/driver/browser/baseDriver.ts

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { getTopLeftOffset, getClientArea } from 'vs/base/browser/dom';
+import { coalesce } from 'vs/base/common/arrays';
+import { IElement, IWindowDriver } from 'vs/platform/driver/common/driver';
+
+function serializeElement(element: Element, recursive: boolean): IElement {
+	const attributes = Object.create(null);
+
+	for (let j = 0; j < element.attributes.length; j++) {
+		const attr = element.attributes.item(j);
+		if (attr) {
+			attributes[attr.name] = attr.value;
+		}
+	}
+
+	const children: IElement[] = [];
+
+	if (recursive) {
+		for (let i = 0; i < element.children.length; i++) {
+			const child = element.children.item(i);
+			if (child) {
+				children.push(serializeElement(child, true));
+			}
+		}
+	}
+
+	const { left, top } = getTopLeftOffset(element as HTMLElement);
+
+	return {
+		tagName: element.tagName,
+		className: element.className,
+		textContent: element.textContent || '',
+		attributes,
+		children,
+		left,
+		top
+	};
+}
+
+export abstract class BaseWindowDriver implements IWindowDriver {
+
+	abstract click(selector: string, xoffset?: number, yoffset?: number): Promise<void>;
+	abstract doubleClick(selector: string): Promise<void>;
+
+	async setValue(selector: string, text: string): Promise<void> {
+		const element = document.querySelector(selector);
+
+		if (!element) {
+			return Promise.reject(new Error(`Element not found: ${selector}`));
+		}
+
+		const inputElement = element as HTMLInputElement;
+		inputElement.value = text;
+
+		const event = new Event('input', { bubbles: true, cancelable: true });
+		inputElement.dispatchEvent(event);
+	}
+
+	async getTitle(): Promise<string> {
+		return document.title;
+	}
+
+	async isActiveElement(selector: string): Promise<boolean> {
+		const element = document.querySelector(selector);
+
+		if (element !== document.activeElement) {
+			const chain: string[] = [];
+			let el = document.activeElement;
+
+			while (el) {
+				const tagName = el.tagName;
+				const id = el.id ? `#${el.id}` : '';
+				const classes = coalesce(el.className.split(/\s+/g).map(c => c.trim())).map(c => `.${c}`).join('');
+				chain.unshift(`${tagName}${id}${classes}`);
+
+				el = el.parentElement;
+			}
+
+			throw new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`);
+		}
+
+		return true;
+	}
+
+	async getElements(selector: string, recursive: boolean): Promise<IElement[]> {
+		const query = document.querySelectorAll(selector);
+		const result: IElement[] = [];
+
+		for (let i = 0; i < query.length; i++) {
+			const element = query.item(i);
+			result.push(serializeElement(element, recursive));
+		}
+
+		return result;
+	}
+
+	async getElementXY(selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }> {
+		const offset = typeof xoffset === 'number' && typeof yoffset === 'number' ? { x: xoffset, y: yoffset } : undefined;
+		return this._getElementXY(selector, offset);
+	}
+
+	async typeInEditor(selector: string, text: string): Promise<void> {
+		const element = document.querySelector(selector);
+
+		if (!element) {
+			throw new Error(`Editor not found: ${selector}`);
+		}
+
+		const textarea = element as HTMLTextAreaElement;
+		const start = textarea.selectionStart;
+		const newStart = start + text.length;
+		const value = textarea.value;
+		const newValue = value.substr(0, start) + text + value.substr(start);
+
+		textarea.value = newValue;
+		textarea.setSelectionRange(newStart, newStart);
+
+		const event = new Event('input', { 'bubbles': true, 'cancelable': true });
+		textarea.dispatchEvent(event);
+	}
+
+	async getTerminalBuffer(selector: string): Promise<string[]> {
+		const element = document.querySelector(selector);
+
+		if (!element) {
+			throw new Error(`Terminal not found: ${selector}`);
+		}
+
+		const xterm = (element as any).xterm;
+
+		if (!xterm) {
+			throw new Error(`Xterm not found: ${selector}`);
+		}
+
+		const lines: string[] = [];
+
+		for (let i = 0; i < xterm.buffer.length; i++) {
+			lines.push(xterm.buffer.getLine(i)!.translateToString(true));
+		}
+
+		return lines;
+	}
+
+	async writeInTerminal(selector: string, text: string): Promise<void> {
+		const element = document.querySelector(selector);
+
+		if (!element) {
+			throw new Error(`Element not found: ${selector}`);
+		}
+
+		const xterm = (element as any).xterm;
+
+		if (!xterm) {
+			throw new Error(`Xterm not found: ${selector}`);
+		}
+
+		xterm._core._coreService.triggerDataEvent(text);
+	}
+
+	protected async _getElementXY(selector: string, offset?: { x: number, y: number }): Promise<{ x: number; y: number; }> {
+		const element = document.querySelector(selector);
+
+		if (!element) {
+			return Promise.reject(new Error(`Element not found: ${selector}`));
+		}
+
+		const { left, top } = getTopLeftOffset(element as HTMLElement);
+		const { width, height } = getClientArea(element as HTMLElement);
+		let x: number, y: number;
+
+		if (offset) {
+			x = left + offset.x;
+			y = top + offset.y;
+		} else {
+			x = left + (width / 2);
+			y = top + (height / 2);
+		}
+
+		x = Math.round(x);
+		y = Math.round(y);
+
+		return { x, y };
+	}
+
+	abstract openDevTools(): Promise<void>;
+}

lib/vscode/src/vs/platform/driver/browser/driver.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+import { BaseWindowDriver } from 'vs/platform/driver/browser/baseDriver';
+
+class BrowserWindowDriver extends BaseWindowDriver {
+	click(selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Promise<void> {
+		throw new Error('Method not implemented.');
+	}
+	doubleClick(selector: string): Promise<void> {
+		throw new Error('Method not implemented.');
+	}
+	openDevTools(): Promise<void> {
+		throw new Error('Method not implemented.');
+	}
+}
+
+export async function registerWindowDriver(): Promise<IDisposable> {
+	(<any>window).driver = new BrowserWindowDriver();
+
+	return Disposable.None;
+}

lib/vscode/src/vs/platform/driver/common/driver.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.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+
+// !! Do not remove the following START and END markers, they are parsed by the smoketest build
+
+//*START
+export interface IElement {
+	tagName: string;
+	className: string;
+	textContent: string;
+	attributes: { [name: string]: string; };
+	children: IElement[];
+	top: number;
+	left: number;
+}
+
+export interface IDriver {
+	readonly _serviceBrand: undefined;
+
+	getWindowIds(): Promise<number[]>;
+	capturePage(windowId: number): Promise<string>;
+	reloadWindow(windowId: number): Promise<void>;
+	exitApplication(): Promise<void>;
+	dispatchKeybinding(windowId: number, keybinding: string): Promise<void>;
+	click(windowId: number, selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Promise<void>;
+	doubleClick(windowId: number, selector: string): Promise<void>;
+	setValue(windowId: number, selector: string, text: string): Promise<void>;
+	getTitle(windowId: number): Promise<string>;
+	isActiveElement(windowId: number, selector: string): Promise<boolean>;
+	getElements(windowId: number, selector: string, recursive?: boolean): Promise<IElement[]>;
+	getElementXY(windowId: number, selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }>;
+	typeInEditor(windowId: number, selector: string, text: string): Promise<void>;
+	getTerminalBuffer(windowId: number, selector: string): Promise<string[]>;
+	writeInTerminal(windowId: number, selector: string, text: string): Promise<void>;
+}
+//*END
+
+export const ID = 'driverService';
+export const IDriver = createDecorator<IDriver>(ID);
+
+export interface IWindowDriver {
+	click(selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Promise<void>;
+	doubleClick(selector: string): Promise<void>;
+	setValue(selector: string, text: string): Promise<void>;
+	getTitle(): Promise<string>;
+	isActiveElement(selector: string): Promise<boolean>;
+	getElements(selector: string, recursive: boolean): Promise<IElement[]>;
+	getElementXY(selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }>;
+	typeInEditor(selector: string, text: string): Promise<void>;
+	getTerminalBuffer(selector: string): Promise<string[]>;
+	writeInTerminal(selector: string, text: string): Promise<void>;
+}

lib/vscode/src/vs/platform/driver/electron-browser/driver.ts

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/node/driver';
+import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { timeout } from 'vs/base/common/async';
+import { BaseWindowDriver } from 'vs/platform/driver/browser/baseDriver';
+import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
+
+class WindowDriver extends BaseWindowDriver {
+
+	constructor(
+		@INativeHostService private readonly nativeHostService: INativeHostService
+	) {
+		super();
+	}
+
+	click(selector: string, xoffset?: number, yoffset?: number): Promise<void> {
+		const offset = typeof xoffset === 'number' && typeof yoffset === 'number' ? { x: xoffset, y: yoffset } : undefined;
+		return this._click(selector, 1, offset);
+	}
+
+	doubleClick(selector: string): Promise<void> {
+		return this._click(selector, 2);
+	}
+
+	private async _click(selector: string, clickCount: number, offset?: { x: number, y: number }): Promise<void> {
+		const { x, y } = await this._getElementXY(selector, offset);
+
+		await this.nativeHostService.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount } as any);
+		await timeout(10);
+
+		await this.nativeHostService.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount } as any);
+		await timeout(100);
+	}
+
+	async openDevTools(): Promise<void> {
+		await this.nativeHostService.openDevTools({ mode: 'detach' });
+	}
+}
+
+export async function registerWindowDriver(accessor: ServicesAccessor, windowId: number): Promise<IDisposable> {
+	const instantiationService = accessor.get(IInstantiationService);
+	const mainProcessService = accessor.get(IMainProcessService);
+
+	const windowDriver = instantiationService.createInstance(WindowDriver);
+	const windowDriverChannel = new WindowDriverChannel(windowDriver);
+	mainProcessService.registerChannel('windowDriver', windowDriverChannel);
+
+	const windowDriverRegistryChannel = mainProcessService.getChannel('windowDriverRegistry');
+	const windowDriverRegistry = new WindowDriverRegistryChannelClient(windowDriverRegistryChannel);
+
+	await windowDriverRegistry.registerWindowDriver(windowId);
+	// const options = await windowDriverRegistry.registerWindowDriver(windowId);
+
+	// if (options.verbose) {
+	// 	windowDriver.openDevTools();
+	// }
+
+	return toDisposable(() => windowDriverRegistry.reloadWindowDriver(windowId));
+}

lib/vscode/src/vs/platform/driver/electron-main/driver.ts

@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DriverChannel, WindowDriverChannelClient, IWindowDriverRegistry, WindowDriverRegistryChannel, IDriverOptions } from 'vs/platform/driver/node/driver';
+import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
+import { serve as serveNet } from 'vs/base/parts/ipc/node/ipc.net';
+import { combinedDisposable, IDisposable } from 'vs/base/common/lifecycle';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IPCServer, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
+import { SimpleKeybinding, KeyCode } from 'vs/base/common/keyCodes';
+import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import { OS } from 'vs/base/common/platform';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
+import { ScanCodeBinding } from 'vs/base/common/scanCode';
+import { KeybindingParser } from 'vs/base/common/keybindingParser';
+import { timeout } from 'vs/base/common/async';
+import { IDriver, IElement, IWindowDriver } from 'vs/platform/driver/common/driver';
+import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
+import { INativeHostMainService } from 'vs/platform/native/electron-main/nativeHostMainService';
+
+function isSilentKeyCode(keyCode: KeyCode) {
+	return keyCode < KeyCode.KEY_0;
+}
+
+export class Driver implements IDriver, IWindowDriverRegistry {
+
+	declare readonly _serviceBrand: undefined;
+
+	private registeredWindowIds = new Set<number>();
+	private reloadingWindowIds = new Set<number>();
+	private readonly onDidReloadingChange = new Emitter<void>();
+
+	constructor(
+		private windowServer: IPCServer,
+		private options: IDriverOptions,
+		@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
+		@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService,
+		@INativeHostMainService private readonly nativeHostMainService: INativeHostMainService
+	) { }
+
+	async registerWindowDriver(windowId: number): Promise<IDriverOptions> {
+		this.registeredWindowIds.add(windowId);
+		this.reloadingWindowIds.delete(windowId);
+		this.onDidReloadingChange.fire();
+		return this.options;
+	}
+
+	async reloadWindowDriver(windowId: number): Promise<void> {
+		this.reloadingWindowIds.add(windowId);
+	}
+
+	async getWindowIds(): Promise<number[]> {
+		return this.windowsMainService.getWindows()
+			.map(w => w.id)
+			.filter(id => this.registeredWindowIds.has(id) && !this.reloadingWindowIds.has(id));
+	}
+
+	async capturePage(windowId: number): Promise<string> {
+		await this.whenUnfrozen(windowId);
+
+		const window = this.windowsMainService.getWindowById(windowId);
+		if (!window) {
+			throw new Error('Invalid window');
+		}
+		const webContents = window.win.webContents;
+		const image = await webContents.capturePage();
+		return image.toPNG().toString('base64');
+	}
+
+	async reloadWindow(windowId: number): Promise<void> {
+		await this.whenUnfrozen(windowId);
+
+		const window = this.windowsMainService.getWindowById(windowId);
+		if (!window) {
+			throw new Error('Invalid window');
+		}
+		this.reloadingWindowIds.add(windowId);
+		this.lifecycleMainService.reload(window);
+	}
+
+	async exitApplication(): Promise<void> {
+		return this.nativeHostMainService.quit(undefined);
+	}
+
+	async dispatchKeybinding(windowId: number, keybinding: string): Promise<void> {
+		await this.whenUnfrozen(windowId);
+
+		const parts = KeybindingParser.parseUserBinding(keybinding);
+
+		for (let part of parts) {
+			await this._dispatchKeybinding(windowId, part);
+		}
+	}
+
+	private async _dispatchKeybinding(windowId: number, keybinding: SimpleKeybinding | ScanCodeBinding): Promise<void> {
+		if (keybinding instanceof ScanCodeBinding) {
+			throw new Error('ScanCodeBindings not supported');
+		}
+
+		const window = this.windowsMainService.getWindowById(windowId);
+		if (!window) {
+			throw new Error('Invalid window');
+		}
+		const webContents = window.win.webContents;
+		const noModifiedKeybinding = new SimpleKeybinding(false, false, false, false, keybinding.keyCode);
+		const resolvedKeybinding = new USLayoutResolvedKeybinding(noModifiedKeybinding.toChord(), OS);
+		const keyCode = resolvedKeybinding.getElectronAccelerator();
+
+		const modifiers: string[] = [];
+
+		if (keybinding.ctrlKey) {
+			modifiers.push('ctrl');
+		}
+
+		if (keybinding.metaKey) {
+			modifiers.push('meta');
+		}
+
+		if (keybinding.shiftKey) {
+			modifiers.push('shift');
+		}
+
+		if (keybinding.altKey) {
+			modifiers.push('alt');
+		}
+
+		webContents.sendInputEvent({ type: 'keyDown', keyCode, modifiers } as any);
+
+		if (!isSilentKeyCode(keybinding.keyCode)) {
+			webContents.sendInputEvent({ type: 'char', keyCode, modifiers } as any);
+		}
+
+		webContents.sendInputEvent({ type: 'keyUp', keyCode, modifiers } as any);
+
+		await timeout(100);
+	}
+
+	async click(windowId: number, selector: string, xoffset?: number, yoffset?: number): Promise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		await windowDriver.click(selector, xoffset, yoffset);
+	}
+
+	async doubleClick(windowId: number, selector: string): Promise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		await windowDriver.doubleClick(selector);
+	}
+
+	async setValue(windowId: number, selector: string, text: string): Promise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		await windowDriver.setValue(selector, text);
+	}
+
+	async getTitle(windowId: number): Promise<string> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getTitle();
+	}
+
+	async isActiveElement(windowId: number, selector: string): Promise<boolean> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.isActiveElement(selector);
+	}
+
+	async getElements(windowId: number, selector: string, recursive: boolean): Promise<IElement[]> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getElements(selector, recursive);
+	}
+
+	async getElementXY(windowId: number, selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getElementXY(selector, xoffset, yoffset);
+	}
+
+	async typeInEditor(windowId: number, selector: string, text: string): Promise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		await windowDriver.typeInEditor(selector, text);
+	}
+
+	async getTerminalBuffer(windowId: number, selector: string): Promise<string[]> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getTerminalBuffer(selector);
+	}
+
+	async writeInTerminal(windowId: number, selector: string, text: string): Promise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		await windowDriver.writeInTerminal(selector, text);
+	}
+
+	private async getWindowDriver(windowId: number): Promise<IWindowDriver> {
+		await this.whenUnfrozen(windowId);
+
+		const id = `window:${windowId}`;
+		const router = new StaticRouter(ctx => ctx === id);
+		const windowDriverChannel = this.windowServer.getChannel('windowDriver', router);
+		return new WindowDriverChannelClient(windowDriverChannel);
+	}
+
+	private async whenUnfrozen(windowId: number): Promise<void> {
+		while (this.reloadingWindowIds.has(windowId)) {
+			await Event.toPromise(this.onDidReloadingChange.event);
+		}
+	}
+}
+
+export async function serve(
+	windowServer: IPCServer,
+	handle: string,
+	environmentService: IEnvironmentMainService,
+	instantiationService: IInstantiationService
+): Promise<IDisposable> {
+	const verbose = environmentService.driverVerbose;
+	const driver = instantiationService.createInstance(Driver, windowServer, { verbose });
+
+	const windowDriverRegistryChannel = new WindowDriverRegistryChannel(driver);
+	windowServer.registerChannel('windowDriverRegistry', windowDriverRegistryChannel);
+
+	const server = await serveNet(handle);
+	const channel = new DriverChannel(driver);
+	server.registerChannel('driver', channel);
+
+	return combinedDisposable(server, windowServer);
+}

lib/vscode/src/vs/platform/driver/node/driver.ts

@@ -0,0 +1,230 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Client } from 'vs/base/parts/ipc/common/ipc.net';
+import { connect as connectNet } from 'vs/base/parts/ipc/node/ipc.net';
+import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Event } from 'vs/base/common/event';
+import { IDriver, IElement, IWindowDriver } from 'vs/platform/driver/common/driver';
+
+export class DriverChannel implements IServerChannel {
+
+	constructor(private driver: IDriver) { }
+
+	listen<T>(_: unknown, event: string): Event<T> {
+		throw new Error('No event found');
+	}
+
+	call(_: unknown, command: string, arg?: any): Promise<any> {
+		switch (command) {
+			case 'getWindowIds': return this.driver.getWindowIds();
+			case 'capturePage': return this.driver.capturePage(arg);
+			case 'reloadWindow': return this.driver.reloadWindow(arg);
+			case 'exitApplication': return this.driver.exitApplication();
+			case 'dispatchKeybinding': return this.driver.dispatchKeybinding(arg[0], arg[1]);
+			case 'click': return this.driver.click(arg[0], arg[1], arg[2], arg[3]);
+			case 'doubleClick': return this.driver.doubleClick(arg[0], arg[1]);
+			case 'setValue': return this.driver.setValue(arg[0], arg[1], arg[2]);
+			case 'getTitle': return this.driver.getTitle(arg[0]);
+			case 'isActiveElement': return this.driver.isActiveElement(arg[0], arg[1]);
+			case 'getElements': return this.driver.getElements(arg[0], arg[1], arg[2]);
+			case 'getElementXY': return this.driver.getElementXY(arg[0], arg[1], arg[2]);
+			case 'typeInEditor': return this.driver.typeInEditor(arg[0], arg[1], arg[2]);
+			case 'getTerminalBuffer': return this.driver.getTerminalBuffer(arg[0], arg[1]);
+			case 'writeInTerminal': return this.driver.writeInTerminal(arg[0], arg[1], arg[2]);
+		}
+
+		throw new Error(`Call not found: ${command}`);
+	}
+}
+
+export class DriverChannelClient implements IDriver {
+
+	declare readonly _serviceBrand: undefined;
+
+	constructor(private channel: IChannel) { }
+
+	getWindowIds(): Promise<number[]> {
+		return this.channel.call('getWindowIds');
+	}
+
+	capturePage(windowId: number): Promise<string> {
+		return this.channel.call('capturePage', windowId);
+	}
+
+	reloadWindow(windowId: number): Promise<void> {
+		return this.channel.call('reloadWindow', windowId);
+	}
+
+	exitApplication(): Promise<void> {
+		return this.channel.call('exitApplication');
+	}
+
+	dispatchKeybinding(windowId: number, keybinding: string): Promise<void> {
+		return this.channel.call('dispatchKeybinding', [windowId, keybinding]);
+	}
+
+	click(windowId: number, selector: string, xoffset: number | undefined, yoffset: number | undefined): Promise<void> {
+		return this.channel.call('click', [windowId, selector, xoffset, yoffset]);
+	}
+
+	doubleClick(windowId: number, selector: string): Promise<void> {
+		return this.channel.call('doubleClick', [windowId, selector]);
+	}
+
+	setValue(windowId: number, selector: string, text: string): Promise<void> {
+		return this.channel.call('setValue', [windowId, selector, text]);
+	}
+
+	getTitle(windowId: number): Promise<string> {
+		return this.channel.call('getTitle', [windowId]);
+	}
+
+	isActiveElement(windowId: number, selector: string): Promise<boolean> {
+		return this.channel.call('isActiveElement', [windowId, selector]);
+	}
+
+	getElements(windowId: number, selector: string, recursive: boolean): Promise<IElement[]> {
+		return this.channel.call('getElements', [windowId, selector, recursive]);
+	}
+
+	getElementXY(windowId: number, selector: string, xoffset: number | undefined, yoffset: number | undefined): Promise<{ x: number, y: number }> {
+		return this.channel.call('getElementXY', [windowId, selector, xoffset, yoffset]);
+	}
+
+	typeInEditor(windowId: number, selector: string, text: string): Promise<void> {
+		return this.channel.call('typeInEditor', [windowId, selector, text]);
+	}
+
+	getTerminalBuffer(windowId: number, selector: string): Promise<string[]> {
+		return this.channel.call('getTerminalBuffer', [windowId, selector]);
+	}
+
+	writeInTerminal(windowId: number, selector: string, text: string): Promise<void> {
+		return this.channel.call('writeInTerminal', [windowId, selector, text]);
+	}
+}
+
+export interface IDriverOptions {
+	verbose: boolean;
+}
+
+export interface IWindowDriverRegistry {
+	registerWindowDriver(windowId: number): Promise<IDriverOptions>;
+	reloadWindowDriver(windowId: number): Promise<void>;
+}
+
+export class WindowDriverRegistryChannel implements IServerChannel {
+
+	constructor(private registry: IWindowDriverRegistry) { }
+
+	listen<T>(_: unknown, event: string): Event<T> {
+		throw new Error(`Event not found: ${event}`);
+	}
+
+	call(_: unknown, command: string, arg?: any): Promise<any> {
+		switch (command) {
+			case 'registerWindowDriver': return this.registry.registerWindowDriver(arg);
+			case 'reloadWindowDriver': return this.registry.reloadWindowDriver(arg);
+		}
+
+		throw new Error(`Call not found: ${command}`);
+	}
+}
+
+export class WindowDriverRegistryChannelClient implements IWindowDriverRegistry {
+
+	declare readonly _serviceBrand: undefined;
+
+	constructor(private channel: IChannel) { }
+
+	registerWindowDriver(windowId: number): Promise<IDriverOptions> {
+		return this.channel.call('registerWindowDriver', windowId);
+	}
+
+	reloadWindowDriver(windowId: number): Promise<void> {
+		return this.channel.call('reloadWindowDriver', windowId);
+	}
+}
+
+export class WindowDriverChannel implements IServerChannel {
+
+	constructor(private driver: IWindowDriver) { }
+
+	listen<T>(_: unknown, event: string): Event<T> {
+		throw new Error(`No event found: ${event}`);
+	}
+
+	call(_: unknown, command: string, arg?: any): Promise<any> {
+		switch (command) {
+			case 'click': return this.driver.click(arg[0], arg[1], arg[2]);
+			case 'doubleClick': return this.driver.doubleClick(arg);
+			case 'setValue': return this.driver.setValue(arg[0], arg[1]);
+			case 'getTitle': return this.driver.getTitle();
+			case 'isActiveElement': return this.driver.isActiveElement(arg);
+			case 'getElements': return this.driver.getElements(arg[0], arg[1]);
+			case 'getElementXY': return this.driver.getElementXY(arg[0], arg[1], arg[2]);
+			case 'typeInEditor': return this.driver.typeInEditor(arg[0], arg[1]);
+			case 'getTerminalBuffer': return this.driver.getTerminalBuffer(arg);
+			case 'writeInTerminal': return this.driver.writeInTerminal(arg[0], arg[1]);
+		}
+
+		throw new Error(`Call not found: ${command}`);
+	}
+}
+
+export class WindowDriverChannelClient implements IWindowDriver {
+
+	declare readonly _serviceBrand: undefined;
+
+	constructor(private channel: IChannel) { }
+
+	click(selector: string, xoffset?: number, yoffset?: number): Promise<void> {
+		return this.channel.call('click', [selector, xoffset, yoffset]);
+	}
+
+	doubleClick(selector: string): Promise<void> {
+		return this.channel.call('doubleClick', selector);
+	}
+
+	setValue(selector: string, text: string): Promise<void> {
+		return this.channel.call('setValue', [selector, text]);
+	}
+
+	getTitle(): Promise<string> {
+		return this.channel.call('getTitle');
+	}
+
+	isActiveElement(selector: string): Promise<boolean> {
+		return this.channel.call('isActiveElement', selector);
+	}
+
+	getElements(selector: string, recursive: boolean): Promise<IElement[]> {
+		return this.channel.call('getElements', [selector, recursive]);
+	}
+
+	getElementXY(selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number, y: number }> {
+		return this.channel.call('getElementXY', [selector, xoffset, yoffset]);
+	}
+
+	typeInEditor(selector: string, text: string): Promise<void> {
+		return this.channel.call('typeInEditor', [selector, text]);
+	}
+
+	getTerminalBuffer(selector: string): Promise<string[]> {
+		return this.channel.call('getTerminalBuffer', selector);
+	}
+
+	writeInTerminal(selector: string, text: string): Promise<void> {
+		return this.channel.call('writeInTerminal', [selector, text]);
+	}
+}
+
+export async function connect(handle: string): Promise<{ client: Client, driver: IDriver }> {
+	const client = await connectNet(handle, 'driverClient');
+	const channel = client.getChannel('driver');
+	const driver = new DriverChannelClient(channel);
+	return { client, driver };
+}