Integrated Browser

src/vs/base/common/keyCodes.ts

@@ -456,6 +456,7 @@ const userSettingsUSMap = new KeyCodeStrMap();
 const userSettingsGeneralMap = new KeyCodeStrMap();
 export const EVENT_KEY_CODE_MAP: { [keyCode: number]: KeyCode } = new Array(230);
 export const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE: { [nativeKeyCode: string]: KeyCode } = {};
+export const SCAN_CODE_STR_TO_EVENT_KEY_CODE: { [scanCodeStr: string]: number } = {};
 const scanCodeIntToStr: string[] = [];
 const scanCodeStrToInt: { [code: string]: number } = Object.create(null);
 const scanCodeLowerCaseStrToInt: { [code: string]: number } = Object.create(null);
@@ -755,6 +756,9 @@ for (let i = 0; i <= KeyCode.MAX_VALUE; i++) {
 		if (eventKeyCode) {
 			EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;
 		}
+		if (scanCodeStr) {
+			SCAN_CODE_STR_TO_EVENT_KEY_CODE[scanCodeStr] = eventKeyCode;
+		}
 		if (vkey) {
 			NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;
 		}

src/vs/base/common/network.ts

@@ -100,6 +100,11 @@ export namespace Schemas {
 	 */
 	export const vscodeWebview = 'vscode-webview';
 
+	/**
+	 * Scheme used for integrated browser tabs using WebContentsView.
+	 */
+	export const vscodeBrowser = 'vscode-browser';
+
 	/**
 	 * Scheme used for extension pages
 	 */

src/vs/code/electron-main/app.ts

@@ -36,6 +36,8 @@ import { DialogMainService, IDialogMainService } from '../../platform/dialogs/el
 import { IEncryptionMainService } from '../../platform/encryption/common/encryptionService.js';
 import { EncryptionMainService } from '../../platform/encryption/electron-main/encryptionMainService.js';
 import { NativeBrowserElementsMainService, INativeBrowserElementsMainService } from '../../platform/browserElements/electron-main/nativeBrowserElementsMainService.js';
+import { ipcBrowserViewChannelName } from '../../platform/browserView/common/browserView.js';
+import { BrowserViewMainService, IBrowserViewMainService } from '../../platform/browserView/electron-main/browserViewMainService.js';
 import { NativeParsedArgs } from '../../platform/environment/common/argv.js';
 import { IEnvironmentMainService } from '../../platform/environment/electron-main/environmentMainService.js';
 import { isLaunchedFromCli } from '../../platform/environment/node/argvHelper.js';
@@ -411,11 +413,15 @@ export class CodeApplication extends Disposable {
 				this.auxiliaryWindowsMainService?.registerWindow(contents);
 			}
 
-			// Block any in-page navigation
+			// Handle any in-page navigation
 			contents.on('will-navigate', event => {
+				if (BrowserViewMainService.isBrowserViewWebContents(contents)) {
+					return; // Allow navigation in integrated browser views
+				}
+
 				this.logService.error('webContents#will-navigate: Prevented webcontent navigation');
 
-				event.preventDefault();
+				event.preventDefault(); // Prevent any in-page navigation
 			});
 
 			// All Windows: only allow about:blank auxiliary windows to open
@@ -1021,6 +1027,9 @@ export class CodeApplication extends Disposable {
 		// Browser Elements
 		services.set(INativeBrowserElementsMainService, new SyncDescriptor(NativeBrowserElementsMainService, undefined, false /* proxied to other processes */));
 
+		// Browser View
+		services.set(IBrowserViewMainService, new SyncDescriptor(BrowserViewMainService, undefined, false /* proxied to other processes */));
+
 		// Keyboard Layout
 		services.set(IKeyboardLayoutMainService, new SyncDescriptor(KeyboardLayoutMainService));
 
@@ -1168,6 +1177,10 @@ export class CodeApplication extends Disposable {
 		mainProcessElectronServer.registerChannel('browserElements', browserElementsChannel);
 		sharedProcessClient.then(client => client.registerChannel('browserElements', browserElementsChannel));
 
+		// Browser View
+		const browserViewChannel = ProxyChannel.fromService(accessor.get(IBrowserViewMainService), disposables);
+		mainProcessElectronServer.registerChannel(ipcBrowserViewChannelName, browserViewChannel);
+
 		// Signing
 		const signChannel = ProxyChannel.fromService(accessor.get(ISignService), disposables);
 		mainProcessElectronServer.registerChannel('sign', signChannel);

src/vs/platform/actions/common/actions.ts

@@ -283,6 +283,8 @@ export class MenuId {
 	static readonly MultiDiffEditorFileToolbar = new MenuId('MultiDiffEditorFileToolbar');
 	static readonly DiffEditorHunkToolbar = new MenuId('DiffEditorHunkToolbar');
 	static readonly DiffEditorSelectionToolbar = new MenuId('DiffEditorSelectionToolbar');
+	static readonly BrowserNavigationToolbar = new MenuId('BrowserNavigationToolbar');
+	static readonly BrowserActionsToolbar = new MenuId('BrowserActionsToolbar');
 	static readonly AgentSessionsViewerFilterSubMenu = new MenuId('AgentSessionsViewerFilterSubMenu');
 	static readonly AgentSessionsContext = new MenuId('AgentSessionsContext');
 	static readonly AgentSessionsCreateSubMenu = new MenuId('AgentSessionsCreateSubMenu');

src/vs/platform/browserView/common/browserView.ts

@@ -0,0 +1,216 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event } from '../../../base/common/event.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
+
+export interface IBrowserViewBounds {
+	windowId: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+	zoomFactor: number;
+}
+
+export interface IBrowserViewCaptureScreenshotOptions {
+	quality?: number;
+	rect?: { x: number; y: number; width: number; height: number };
+}
+
+export interface IBrowserViewState {
+	url: string;
+	title: string;
+	canGoBack: boolean;
+	canGoForward: boolean;
+	loading: boolean;
+	isDevToolsOpen: boolean;
+	lastScreenshot: VSBuffer | undefined;
+	lastFavicon: string | undefined;
+	lastError: IBrowserViewLoadError | undefined;
+	storageScope: BrowserViewStorageScope;
+}
+
+export interface IBrowserViewNavigationEvent {
+	url: string;
+	canGoBack: boolean;
+	canGoForward: boolean;
+}
+
+export interface IBrowserViewLoadingEvent {
+	loading: boolean;
+	error?: IBrowserViewLoadError;
+}
+
+export interface IBrowserViewLoadError {
+	url: string;
+	errorCode: number;
+	errorDescription: string;
+}
+
+export interface IBrowserViewFocusEvent {
+	focused: boolean;
+}
+
+export interface IBrowserViewDevToolsStateEvent {
+	isDevToolsOpen: boolean;
+}
+
+export interface IBrowserViewKeyDownEvent {
+	key: string;
+	keyCode: number;
+	code: string;
+	ctrlKey: boolean;
+	shiftKey: boolean;
+	altKey: boolean;
+	metaKey: boolean;
+	repeat: boolean;
+}
+
+export interface IBrowserViewTitleChangeEvent {
+	title: string;
+}
+
+export interface IBrowserViewFaviconChangeEvent {
+	favicon: string;
+}
+
+export interface IBrowserViewNewPageRequest {
+	url: string;
+	name?: string;
+	background: boolean;
+}
+
+export enum BrowserViewStorageScope {
+	Global = 'global',
+	Workspace = 'workspace',
+	Ephemeral = 'ephemeral'
+}
+
+export const ipcBrowserViewChannelName = 'browserView';
+
+export interface IBrowserViewService {
+	/**
+	 * Dynamic events that return an Event for a specific browser view ID.
+	 */
+	onDynamicDidNavigate(id: string): Event<IBrowserViewNavigationEvent>;
+	onDynamicDidChangeLoadingState(id: string): Event<IBrowserViewLoadingEvent>;
+	onDynamicDidChangeFocus(id: string): Event<IBrowserViewFocusEvent>;
+	onDynamicDidChangeDevToolsState(id: string): Event<IBrowserViewDevToolsStateEvent>;
+	onDynamicDidKeyCommand(id: string): Event<IBrowserViewKeyDownEvent>;
+	onDynamicDidChangeTitle(id: string): Event<IBrowserViewTitleChangeEvent>;
+	onDynamicDidChangeFavicon(id: string): Event<IBrowserViewFaviconChangeEvent>;
+	onDynamicDidRequestNewPage(id: string): Event<IBrowserViewNewPageRequest>;
+	onDynamicDidClose(id: string): Event<void>;
+
+	/**
+	 * Get or create a browser view instance
+	 * @param id The browser view identifier
+	 * @param scope The storage scope for the browser view. Ignored if the view already exists.
+	 * @param workspaceId Workspace identifier for session isolation. Only used if scope is 'workspace'.
+	 */
+	getOrCreateBrowserView(id: string, scope: BrowserViewStorageScope, workspaceId?: string): Promise<IBrowserViewState>;
+
+	/**
+	 * Destroy a browser view instance
+	 * @param id The browser view identifier
+	 */
+	destroyBrowserView(id: string): Promise<void>;
+
+	/**
+	 * Update the bounds of a browser view
+	 * @param id The browser view identifier
+	 * @param bounds The new bounds for the view
+	 */
+	layout(id: string, bounds: IBrowserViewBounds): Promise<void>;
+
+	/**
+	 * Set the visibility of a browser view
+	 * @param id The browser view identifier
+	 * @param visible Whether the view should be visible
+	 */
+	setVisible(id: string, visible: boolean): Promise<void>;
+
+	/**
+	 * Navigate the browser view to a URL
+	 * @param id The browser view identifier
+	 * @param url The URL to navigate to
+	 */
+	loadURL(id: string, url: string): Promise<void>;
+
+	/**
+	 * Get the current URL of a browser view
+	 * @param id The browser view identifier
+	 */
+	getURL(id: string): Promise<string>;
+
+	/**
+	 * Go back in navigation history
+	 * @param id The browser view identifier
+	 */
+	goBack(id: string): Promise<void>;
+
+	/**
+	 * Go forward in navigation history
+	 * @param id The browser view identifier
+	 */
+	goForward(id: string): Promise<void>;
+
+	/**
+	 * Reload the current page
+	 * @param id The browser view identifier
+	 */
+	reload(id: string): Promise<void>;
+
+	/**
+	 * Toggle developer tools for the browser view.
+	 * @param id The browser view identifier
+	 */
+	toggleDevTools(id: string): Promise<void>;
+
+	/**
+	 * Check if the view can go back
+	 * @param id The browser view identifier
+	 */
+	canGoBack(id: string): Promise<boolean>;
+
+	/**
+	 * Check if the view can go forward
+	 * @param id The browser view identifier
+	 */
+	canGoForward(id: string): Promise<boolean>;
+
+	/**
+	 * Capture a screenshot of the browser view
+	 * @param id The browser view identifier
+	 * @param options Screenshot options (quality and rect)
+	 * @returns Screenshot as a buffer
+	 */
+	captureScreenshot(id: string, options?: IBrowserViewCaptureScreenshotOptions): Promise<VSBuffer>;
+
+	/**
+	 * Dispatch a key event to the browser view
+	 * @param id The browser view identifier
+	 * @param keyEvent The key event data
+	 */
+	dispatchKeyEvent(id: string, keyEvent: IBrowserViewKeyDownEvent): Promise<void>;
+
+	/**
+	 * Focus the browser view
+	 * @param id The browser view identifier
+	 */
+	focus(id: string): Promise<void>;
+
+	/**
+	 * Clear all storage data for the global browser session
+	 */
+	clearGlobalStorage(): Promise<void>;
+
+	/**
+	 * Clear all storage data for a specific workspace browser session
+	 * @param workspaceId The workspace identifier
+	 */
+	clearWorkspaceStorage(workspaceId: string): Promise<void>;
+}

src/vs/platform/browserView/common/browserViewUri.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+import { generateUuid } from '../../../base/common/uuid.js';
+
+/**
+ * Helper for creating and parsing browser view URIs.
+ */
+export namespace BrowserViewUri {
+
+	export const scheme = Schemas.vscodeBrowser;
+
+	/**
+	 * Creates a resource URI for a browser view with the given URL.
+	 * Optionally accepts an ID; if not provided, a new UUID is generated.
+	 */
+	export function forUrl(url: string | undefined, id?: string): URI {
+		const viewId = id ?? generateUuid();
+		return URI.from({
+			scheme,
+			path: `/${viewId}`,
+			query: url ? `url=${encodeURIComponent(url)}` : undefined
+		});
+	}
+
+	/**
+	 * Parses a browser view resource URI to extract the ID and URL.
+	 */
+	export function parse(resource: URI): { id: string; url: string } | undefined {
+		if (resource.scheme !== scheme) {
+			return undefined;
+		}
+
+		// Remove leading slash if present
+		const id = resource.path.startsWith('/') ? resource.path.substring(1) : resource.path;
+		if (!id) {
+			return undefined;
+		}
+
+		const url = resource.query ? new URLSearchParams(resource.query).get('url') ?? '' : '';
+
+		return { id, url };
+	}
+
+	/**
+	 * Extracts the ID from a browser view resource URI.
+	 */
+	export function getId(resource: URI): string | undefined {
+		return parse(resource)?.id;
+	}
+
+	/**
+	 * Extracts the URL from a browser view resource URI.
+	 */
+	export function getUrl(resource: URI): string | undefined {
+		return parse(resource)?.url;
+	}
+}