Fix copy/paste and context menus for Shiny and other content in Viewer pane

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

@@ -226,9 +226,13 @@ export class CodeApplication extends Disposable {
 		};
 
 		const isAllowedWebviewRequest = (uri: URI, details: Electron.OnBeforeRequestListenerDetails): boolean => {
-			if (uri.path !== '/index.html') {
+			// --- Start Positron ---
+			// Add index-external.html to the allowlist. Positron uses this file
+			// to load external URLs into weviews.
+			if (uri.path !== '/index.html' && uri.path !== '/index-external.html') {
 				return true; // Only restrict top level page of webviews: index.html
 			}
+			// --- End Positron ---
 
 			const frame = details.frame;
 			if (!frame || !this.windowsMainService) {

src/vs/platform/webview/common/webviewManagerService.ts

@@ -21,6 +21,28 @@ export interface WebviewWindowId {
 }
 
 // --- Start Positron ---
+/**
+ * A unique composite identifier for a frame inside a webview.
+ */
+export interface WebviewFrameId {
+	/** The process ID that backs the frame */
+	readonly processId: number;
+
+	/** The frame's routing identifier */
+	readonly routingId: number;
+}
+
+/**
+ * An event fired when a frame navigates to a new URL.
+ */
+export interface FrameNavigationEvent {
+	/** The ID of the frame that navigated */
+	readonly frameId: WebviewFrameId;
+
+	/** The frame's new URL */
+	readonly url: string;
+}
+
 export interface WebviewRectangle {
 	readonly x: number;
 	readonly y: number;
@@ -55,6 +77,36 @@ export interface IWebviewManagerService {
 	stopFindInFrame(windowId: WebviewWindowId, frameName: string, options: { keepSelection?: boolean }): Promise<void>;
 
 	// --- Start Positron ---
+	/**
+	 * Waits for a frame with the given target URL to be created in a webview;
+	 * when it has been created, returns the frame id.
+	 *
+	 * @param windowId The window id of the webview in which the frame is to be created.
+	 * @param targetUrl The URL of the frame to wait for.
+	 */
+	awaitFrameCreation(windowId: WebviewWindowId, targetUrl: string): Promise<WebviewFrameId>;
+
+	/**
+	 * An event fired when a webview frame has navigated to a new URL.
+	 */
+	onFrameNavigation: Event<FrameNavigationEvent>;
+
+	/**
+	 * Capture a snapshot of the contents of a webview as a PNG image.
+	 *
+	 * @param windowId The window id of the webview to capture.
+	 * @param area The area of the webview to capture, in CSS pixels.
+	 */
 	captureContentsAsPng(windowId: WebviewWindowId, area?: WebviewRectangle): Promise<VSBuffer | undefined>;
+
+	/**
+	 * Execute JavaScript code in a webview frame.
+	 *
+	 * @param frameId The ID of the frame in which to execute the code.
+	 * @param code The code to execute.
+	 *
+	 * @returns A promise that resolves to the result of the code execution.
+	 */
+	executeJavaScript(frameId: WebviewFrameId, code: string): Promise<any>;
 	// --- End Positron ---
 }

src/vs/platform/webview/electron-main/webviewMainService.ts

@@ -12,8 +12,15 @@ import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
 
 // --- Start Positron ---
 // eslint-disable-next-line no-duplicate-imports
-import { Rectangle } from 'electron';
+import { Rectangle, webFrameMain } from 'electron';
 import { VSBuffer } from 'vs/base/common/buffer';
+
+// eslint-disable-next-line no-duplicate-imports
+import { IDisposable } from 'vs/base/common/lifecycle';
+
+// eslint-disable-next-line no-duplicate-imports
+import { WebviewFrameId, FrameNavigationEvent } from 'vs/platform/webview/common/webviewManagerService';
+import { DeferredPromise } from 'vs/base/common/async';
 // --- End Positron ---
 
 export class WebviewMainService extends Disposable implements IWebviewManagerService {
@@ -91,6 +98,21 @@ export class WebviewMainService extends Disposable implements IWebviewManagerSer
 	}
 
 	// --- Start Positron ---
+
+	// The onFrameNavigated event is fired when a frame in a webview navigates to
+	// a new URL.
+	private readonly _onFrameNavigated = this._register(new Emitter<FrameNavigationEvent>());
+	public onFrameNavigation = this._onFrameNavigated.event;
+
+	// A map of window IDs to disposables for navigation event listeners. We
+	// attach a single listener to each window to capture frame navigation
+	// events.
+	private readonly _navigationListeners = new Map<WebviewWindowId, IDisposable>();
+
+	// A map of pending frame navigations, from the URL of the frame to the
+	// promise that will be resolved when a frame navigates to that URL.
+	private readonly _pendingNavigations = new Map<string, DeferredPromise<WebviewFrameId>>();
+
 	/**
 	 * Captures the contents of the webview in the given window as a PNG image.
 	 *
@@ -110,6 +132,85 @@ export class WebviewMainService extends Disposable implements IWebviewManagerSer
 		const image = await contents.capturePage(area);
 		return VSBuffer.wrap(image.toPNG());
 	}
+
+	/**
+	 * Waits for a frame to be created in a webview.
+	 *
+	 * @param windowId The ID of the window containing the webview
+	 * @param targetUrl The URL of the frame to await creation of
+	 * @returns A unique identifier for the frame
+	 */
+	public async awaitFrameCreation(windowId: WebviewWindowId, targetUrl: string): Promise<WebviewFrameId> {
+		// Get the window containing the webview
+		const window = this.windowsMainService.getWindowById(windowId.windowId);
+		if (!window?.win) {
+			throw new Error(`Invalid windowId: ${windowId}`);
+		}
+
+		// If we aren't already listening for navigation events on this window,
+		// set up a listener to capture them
+		if (!this._navigationListeners.has(windowId)) {
+			// Event handler for navigation events
+			const onNavigated = (_event: any,
+				url: string,
+				_httpResponseCode: number,
+				_httpStatusText: string,
+				_isMainFrame: boolean,
+				frameProcessId: number,
+				frameRoutingId: number) => {
+				const frameId = { processId: frameProcessId, routingId: frameRoutingId };
+				this.onFrameNavigated(frameId, url);
+			};
+			window.win!.webContents.on('did-frame-navigate', onNavigated);
+
+			// Disposable for the listener
+			const disposable = { dispose: () => window.win!.webContents.off('did-frame-navigate', onNavigated) };
+			this._navigationListeners.set(windowId, disposable);
+
+			// Register the disposable so we can clean up when the service is
+			// disposed
+			this._register(disposable);
+		}
+
+		// Create a new deferred promise; it will be resolved when the frame
+		// navigates to the target URL.
+		const deferred = new DeferredPromise<WebviewFrameId>();
+		this._pendingNavigations.set(targetUrl, deferred);
+		return deferred.p;
+	}
+
+	/**
+	 * Executes a JavaScript code snippet in a webview frame.
+	 *
+	 * @param frameId The ID of the frame in which to execute the code.
+	 * @param script The code to execute, as a string.
+	 * @returns The result of evaluating the code.
+	 */
+	public async executeJavaScript(frameId: WebviewFrameId, script: string): Promise<any> {
+		const frame = webFrameMain.fromId(frameId.processId, frameId.routingId);
+		if (!frame) {
+			throw new Error(`No frame found with frameId: ${JSON.stringify(frameId)}`);
+		}
+		return frame.executeJavaScript(script);
+	}
+
+	/**
+	 * Handles a frame navigation event.
+	 * @param frameId The ID of the frame that navigated
+	 * @param url The URL to which the frame navigated
+	 */
+	private onFrameNavigated(frameId: WebviewFrameId, url: string): void {
+		this._onFrameNavigated.fire({ frameId, url });
+
+		// Check for any pending navigations that match this URL; if we find
+		// any, complete them
+		if (this._pendingNavigations.has(url)) {
+			const deferred = this._pendingNavigations.get(url);
+			deferred!.complete(frameId);
+			this._pendingNavigations.delete(url);
+		}
+	}
+
 	// --- End Positron ---
 
 	private getFrameByName(windowId: WebviewWindowId, frameName: string): WebFrameMain {

src/vs/platform/webview/electron-main/webviewProtocolProvider.ts

@@ -14,6 +14,11 @@ export class WebviewProtocolProvider extends Disposable {
 	private static validWebviewFilePaths = new Map([
 		['/index.html', 'index.html'],
 		['/fake.html', 'fake.html'],
+		// --- Start Positron ---
+		// Add 'index-external' to the list of valid webview file paths. This is
+		// used as a host iframe when loading external URLs in Positron.
+		['/index-external.html', 'index-external.html'],
+		// --- End Positron ---
 		['/service-worker.js', 'service-worker.js'],
 	]);
 

src/vs/workbench/contrib/positronPreview/browser/components/actionBars.tsx

@@ -4,7 +4,7 @@
 
 import 'vs/css!./actionBars';
 import * as React from 'react';
-import { PropsWithChildren, } from 'react'; // eslint-disable-line no-duplicate-imports
+import { PropsWithChildren, useEffect, } from 'react'; // eslint-disable-line no-duplicate-imports
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
@@ -17,12 +17,13 @@ import { PositronSessionsServices } from 'vs/workbench/contrib/positronRuntimeSe
 import { ActionBarRegion } from 'vs/platform/positronActionBar/browser/components/actionBarRegion';
 import { ActionBarButton } from 'vs/platform/positronActionBar/browser/components/actionBarButton';
 import { localize } from 'vs/nls';
-import { PreviewUrl } from 'vs/workbench/contrib/positronPreview/browser/previewUrl';
+import { PreviewUrl, QUERY_NONCE_PARAMETER } from 'vs/workbench/contrib/positronPreview/browser/previewUrl';
 import { IPositronPreviewService } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewSevice';
 import { ActionBarSeparator } from 'vs/platform/positronActionBar/browser/components/actionBarSeparator';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { URI } from 'vs/base/common/uri';
 import { INotificationService } from 'vs/platform/notification/common/notification';
+import { DisposableStore } from 'vs/base/common/lifecycle';
 
 // Constants.
 const kPaddingLeft = 8;
@@ -69,17 +70,26 @@ export const ActionBars = (props: PropsWithChildren<ActionBarsProps>) => {
 
 	// Handler for the navigate back button.
 	const navigateBackHandler = () => {
-		props.preview.webview.postMessage({ command: 'back' });
+		props.preview.webview.postMessage({
+			channel: 'execCommand',
+			data: 'navigate-back'
+		});
 	};
 
 	// Handler for the navigate forward button.
 	const navigateForwardHandler = () => {
-		props.preview.webview.postMessage({ command: 'forward' });
+		props.preview.webview.postMessage({
+			channel: 'execCommand',
+			data: 'navigate-forward'
+		});
 	};
 
 	// Handler for the reload button.
 	const reloadHandler = () => {
-		props.preview.webview.postMessage({ command: 'reload' });
+		props.preview.webview.postMessage({
+			channel: 'execCommand',
+			data: 'reload-window'
+		});
 	};
 
 	// Handler for the clear button.
@@ -131,6 +141,35 @@ export const ActionBars = (props: PropsWithChildren<ActionBarsProps>) => {
 		}
 	};
 
+	// useEffect hook.
+	useEffect(() => {
+		const disposables = new DisposableStore();
+		disposables.add(props.preview.onDidNavigate(e => {
+			if (urlInputRef.current) {
+				// Remove the nonce from the URL before updating the input; we
+				// use this this for cache busting but the user doesn't need to
+				// see it.
+				if (e.query) {
+					const nonceIndex = e.query.indexOf(`${QUERY_NONCE_PARAMETER}=`);
+					if (nonceIndex !== -1) {
+						const nonceEnd = e.query.indexOf('&', nonceIndex);
+						if (nonceEnd !== -1) {
+							e = e.with({
+								query: e.query.slice(0, nonceIndex) + e.query.slice(nonceEnd + 1)
+							});
+						} else {
+							e = e.with({
+								query: e.query.slice(0, nonceIndex)
+							});
+						}
+					}
+				}
+				urlInputRef.current.value = e.toString();
+			}
+		}));
+		return () => disposables.dispose();
+	}, [props.preview]);
+
 	// Render.
 	return (
 		<PositronActionBarContextProvider {...props}>

src/vs/workbench/contrib/positronPreview/browser/positronPreview.contribution.ts

@@ -12,18 +12,13 @@ import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ViewPaneContainer } from 'vs/workbench/browser/parts/views/viewPaneContainer';
-import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { PositronPreviewViewPane } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewView';
-import { PositronPreviewService } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewServiceImpl';
 import { IPositronPreviewService, POSITRON_PREVIEW_VIEW_ID } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewSevice';
 import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
 import { ViewContainer, IViewContainersRegistry, ViewContainerLocation, Extensions as ViewContainerExtensions, IViewsRegistry } from 'vs/workbench/common/views';
 import { registerAction2 } from 'vs/platform/actions/common/actions';
 import { PositronOpenUrlInViewerAction } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewActions';
 
-// Register the Positron preview service.
-registerSingleton(IPositronPreviewService, PositronPreviewService, InstantiationType.Delayed);
-
 // The Positron preview view icon.
 const positronPreviewViewIcon = registerIcon('positron-preview-view-icon', Codicon.positronPreviewView, nls.localize('positronPreviewViewIcon', 'View icon of the Positron preview view.'));
 

src/vs/workbench/contrib/positronPreview/browser/positronPreview.web.contribution.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (C) 2024 Posit Software, PBC. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { PositronPreviewService } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewServiceImpl';
+import { IPositronPreviewService } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewSevice';
+
+// Register the Positron preview service.
+registerSingleton(IPositronPreviewService, PositronPreviewService, InstantiationType.Delayed);

src/vs/workbench/contrib/positronPreview/browser/positronPreviewServiceImpl.ts

@@ -5,7 +5,7 @@
 import { Disposable } from 'vs/base/common/lifecycle';
 import { IPositronPreviewService } from 'vs/workbench/contrib/positronPreview/browser/positronPreview';
 import { Event, Emitter } from 'vs/base/common/event';
-import { IWebviewService, WebviewExtensionDescription, WebviewInitInfo } from 'vs/workbench/contrib/webview/browser/webview';
+import { IOverlayWebview, IWebviewService, WebviewExtensionDescription, WebviewInitInfo } from 'vs/workbench/contrib/webview/browser/webview';
 import { PreviewWebview } from 'vs/workbench/contrib/positronPreview/browser/previewWebview';
 import { IViewsService } from 'vs/workbench/services/views/common/viewsService';
 import { POSITRON_PREVIEW_URL_VIEW_TYPE, POSITRON_PREVIEW_VIEW_ID } from 'vs/workbench/contrib/positronPreview/browser/positronPreviewSevice';
@@ -161,6 +161,7 @@ export class PositronPreviewService extends Disposable implements IPositronPrevi
 			options: {
 				enableFindWidget: true,
 				retainContextWhenHidden: true,
+				externalUri: this.canPreviewExternalUri()
 			},
 			contentOptions: {
 				allowScripts: true,
@@ -172,7 +173,7 @@ export class PositronPreviewService extends Disposable implements IPositronPrevi
 		};
 
 		const webview = this._webviewService.createWebviewOverlay(webviewInitInfo);
-		const preview = new PreviewUrl(previewId, webview, uri);
+		const preview = this.createPreviewUrl(previewId, webview, uri);
 
 		// Remove any other preview URLs from the item list; they can be expensive
 		// to keep around.
@@ -190,6 +191,28 @@ export class PositronPreviewService extends Disposable implements IPositronPrevi
 		return preview;
 	}
 
+	/**
+	 * Creates a URL preview instance.
+	 *
+	 * @param previewId The preview ID
+	 * @param webview The overlay webview instance
+	 * @param uri The URI to open in the preview
+	 * @returns A PreviewUrl instance
+	 */
+	protected createPreviewUrl(previewId: string, webview: IOverlayWebview, uri: URI): PreviewUrl {
+		return new PreviewUrl(previewId, webview, uri);
+	}
+
+	/**
+	 * Indicates whether external URIs can be natively previewed in the viewer.
+	 * Defaults to false; overridden to true in the Electron implementation.
+	 *
+	 * @returns True if external URIs can be previewed in the viewer; false otherwise
+	 */
+	protected canPreviewExternalUri(): boolean {
+		return false;
+	}
+
 	openPreviewWebview(
 		preview: PreviewWebview,
 		preserveFocus?: boolean | undefined