Add notebook consoles; fix reload (#9550)

This change introduces 'notebook consoles', which are consoles that can
be used as a sort of scratchpad for notebooks. A notebook console is
attached to a notebook session; code you run in the console affects the
notebook session, but doesn't appear in the notebook itself, making it
ideal for one-off commands or computations better suited for a REPL than
a throwaway cell.

Notebook consoles appear in the Console tab with a notebook icon instead
of a language logo, and the filename of the notebook listed beside them.

<img width="283" height="161" alt="image"
src="https://github.com/user-attachments/assets/0f4ea9da-2bc5-4f0b-8539-e6b13c833d76"
/>

While useful, these consoles can be kind of confusing to new users
because it gives you two places to run code, and some things work a
little differently when the kernel is in notebook (vs. REPL) mode.
Consequently, the notebook console does not appear by default.

The new command _Console: Show Notebook Console_ will trigger a notebook
console; there's also a button on the new notebooks (and the old ones,
not pictured):

<img width="367" height="69" alt="image"
src="https://github.com/user-attachments/assets/5a95779a-c158-45af-9a3e-9bff0cc85b9c"
/>

For users who always want one of these available, there's an option to
auto-start one for every notebook:

<img width="401" height="100" alt="image"
src="https://github.com/user-attachments/assets/8564b4a7-6c2d-4ec5-8a01-10305e39710c"
/>

While I was in the code, I noticed that reload for notebook sessions has
been broken for a while (see #9453). The problem was a fairly
complicated start loop wherein restoring the session on reload triggered
a pre-registration of the associated runtime, which triggered the
associated notebook kernel to get created, which triggered a session
start again. The fix there is to avoid trying to track the mapping
between sessions and notebook URIs in the runtime kernel service, and to
wait for sessions to be reconnected before trying to auto-start them for
notebooks.


Addresses #3801.
Addresses #9453.


### Release Notes

<!--
Optionally, replace `N/A` with text to be included in the next release
notes.
The `N/A` bullets are ignored. If you refer to one or more Positron
issues,
these issues are used to collect information about the feature or
bugfix, such
as the relevant language pack as determined by Github labels of type
`lang: `.
  The note will automatically be tagged with the language.

These notes are typically filled by the Positron team. If you are an
external
  contributor, you may ignore this section.
-->

#### New Features

- Add an option to attach a console to your notebook's R or Python
session for one-off commands and interactive work (#3801)

#### Bug Fixes

- N/A


### QA Notes

After you create the notebook console, any code you execute in the
notebook will also appear in the notebook's console. This is normal;
it's meant to help you see what's been run leading up to your current
state.

In notebook consoles, running commands that generate non-textual output
(like graphs or HTML content) will often not work correctly, because in
notebook mode this content typically goes to a cell.



This change adds an E2E test to ensure that regression w/ reloading the
window does not occur again.

Author: jmcphers

extensions/positron-r/src/session-manager.ts

@@ -107,8 +107,8 @@ export class RSessionManager implements vscode.Disposable {
 			return;
 		}
 
-		if (session.metadata.sessionMode !== positron.LanguageRuntimeSessionMode.Console) {
-			throw Error(`Foreground session with ID ${sessionId} must be a console session.`);
+		if (session.metadata.sessionMode === positron.LanguageRuntimeSessionMode.Background) {
+			throw Error(`Foreground session with ID ${sessionId} must not be a background session.`);
 		}
 
 		this._lastForegroundSessionId = session.metadata.sessionId;

src/vs/workbench/contrib/positronAssistant/test/browser/positronAssistantService.test.ts

@@ -22,6 +22,8 @@ import { TestRuntimeStartupService } from '../../../../services/runtimeStartup/t
 import { IExecutionHistoryService } from '../../../../services/positronHistory/common/executionHistoryService.js';
 import { createTestPlotsServiceWithPlots } from '../../../../services/positronPlots/test/common/testPlotsServiceHelper.js';
 import { URI } from '../../../../../base/common/uri.js';
+import { IPositronConsoleService } from '../../../../services/positronConsole/browser/interfaces/positronConsoleService.js';
+import { PositronConsoleService } from '../../../../services/positronConsole/browser/positronConsoleService.js';
 
 suite('PositronAssistantService', () => {
 	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
@@ -41,6 +43,7 @@ suite('PositronAssistantService', () => {
 		instantiationService.stub(IRuntimeStartupService, new TestRuntimeStartupService());
 		createRuntimeServices(instantiationService, disposables);
 		instantiationService.stub(IExecutionHistoryService, disposables.add(instantiationService.createInstance(ExecutionHistoryService)));
+		instantiationService.stub(IPositronConsoleService, disposables.add(instantiationService.createInstance(PositronConsoleService)));
 
 		// Create test runtime sessions
 		const runtime = createTestLanguageRuntimeMetadata(instantiationService, disposables);

src/vs/workbench/contrib/positronConsole/browser/components/consoleTabList.tsx

@@ -20,6 +20,8 @@ import { AnchorAlignment, AnchorAxisAlignment } from '../../../../../base/browse
 import { isMacintosh } from '../../../../../base/common/platform.js';
 import { PositronConsoleTabFocused } from '../../../../common/contextkeys.js';
 import { usePositronReactServicesContext } from '../../../../../base/browser/positronReactRendererContext.js';
+import { LanguageRuntimeSessionMode } from '../../../../services/languageRuntime/common/languageRuntimeService.js';
+import { basename } from '../../../../../base/common/path.js';
 
 /**
  * The minimum width required for the delete action to be displayed on the console tab.
@@ -35,14 +37,30 @@ interface ConsoleTabProps {
 }
 
 const ConsoleTab = ({ positronConsoleInstance, width, onChangeSession }: ConsoleTabProps) => {
+
 	// Context
 	const services = usePositronReactServicesContext();
 	const positronConsoleContext = usePositronConsoleContext();
 
+	// Compute session display name
+	const isNotebookSession =
+		positronConsoleInstance.sessionMetadata.sessionMode === LanguageRuntimeSessionMode.Notebook;
+	const session = services.runtimeSessionService.getActiveSession(positronConsoleInstance.sessionId);
+	let sessionDisplayName = '';
+	if (session) {
+		// Ask the session directly
+		sessionDisplayName = session.session.getLabel();
+	} else {
+		// No session to ask, compute from the other metadata we have
+		sessionDisplayName = isNotebookSession ?
+			basename(positronConsoleInstance.sessionMetadata.notebookUri!.path) :
+			positronConsoleInstance.sessionName;
+	}
+
 	// State
 	const [deleteDisabled, setDeleteDisabled] = useState(false);
 	const [isRenamingSession, setIsRenamingSession] = useState(false);
-	const [sessionName, setSessionName] = useState(positronConsoleInstance.sessionName);
+	const [sessionName, setSessionName] = useState(sessionDisplayName);
 
 	// Refs
 	const tabRef = useRef<HTMLDivElement>(null);
@@ -60,7 +78,24 @@ const ConsoleTab = ({ positronConsoleInstance, width, onChangeSession }: Console
 		disposableStore.add(
 			services.runtimeSessionService.onDidUpdateSessionName(session => {
 				if (session.sessionId === positronConsoleInstance.sessionId) {
-					setSessionName(session.dynState.sessionName);
+					setSessionName(session.getLabel());
+				}
+			})
+
+		);
+
+		// Add the onDidUpdateNotebookSessionUri event handler.
+		//
+		// Notebook session URI changes can change what the label shows; if we
+		// get one of these events for our session and there's a new label for
+		// the session, pick it up.
+		disposableStore.add(
+			services.runtimeSessionService.onDidUpdateNotebookSessionUri(e => {
+				if (e.sessionId === sessionId) {
+					const session = services.runtimeSessionService.getActiveSession(sessionId);
+					if (session) {
+						setSessionName(session.session.getLabel());
+					}
 				}
 			})
 		);
@@ -89,20 +124,26 @@ const ConsoleTab = ({ positronConsoleInstance, width, onChangeSession }: Console
 	};
 
 	/**
-	 * The mouse down handler for the parent element of the console tab instance.
-	 * This handler is used to show the context menu when the user right-clicks on a tab.
+	 * The mouse down handler for the parent element of the console tab
+	 * instance.  This handler is used to show the context menu when the user
+	 * right-clicks on a tab.
+	 *
+	 * Notebook consoles can't be renamed, so we currently do not show a context
+	 * menu for them.
 	 */
-	const handleMouseDown = (e: MouseEvent<HTMLDivElement>) => {
-		// Prevent the default action and stop the event from propagating.
-		e.preventDefault();
-		e.stopPropagation();
+	const handleMouseDown = positronConsoleInstance.sessionMetadata.sessionMode ===
+		LanguageRuntimeSessionMode.Notebook ? undefined :
+		(e: MouseEvent<HTMLDivElement>) => {
+			// Prevent the default action and stop the event from propagating.
+			e.preventDefault();
+			e.stopPropagation();
 
-		// Show the context menu when the user right-clicks on a tab or
-		// when the user executes ctrl + left-click on macOS
-		if ((e.button === 0 && isMacintosh && e.ctrlKey) || e.button === 2) {
-			showContextMenu(e.clientX, e.clientY);
+			// Show the context menu when the user right-clicks on a tab or
+			// when the user executes ctrl + left-click on macOS
+			if ((e.button === 0 && isMacintosh && e.ctrlKey) || e.button === 2) {
+				showContextMenu(e.clientX, e.clientY);
+			}
 		}
-	}
 
 	/**
 	 * Shows the context menu when a user right-clicks on a console instance tab.
@@ -328,10 +369,16 @@ const ConsoleTab = ({ positronConsoleInstance, width, onChangeSession }: Console
 			onMouseDown={handleMouseDown}
 		>
 			<ConsoleInstanceState positronConsoleInstance={positronConsoleInstance} />
-			<img
-				className='icon'
-				src={`data:image/svg+xml;base64,${positronConsoleInstance.runtimeMetadata.base64EncodedIconSvg}`}
-			/>
+			{
+				!isNotebookSession &&
+				<img
+					className='icon'
+					src={`data:image/svg+xml;base64,${positronConsoleInstance.runtimeMetadata.base64EncodedIconSvg}`}
+				/>
+			}
+			{isNotebookSession &&
+				<span className='codicon codicon-notebook icon'></span>
+			}
 			{isRenamingSession ? (
 				<input
 					ref={inputRef}

src/vs/workbench/contrib/positronConsole/browser/positronConsoleActions.ts

@@ -17,7 +17,7 @@ import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.j
 import { ILanguageService } from '../../../../editor/common/languages/language.js';
 import { PositronConsoleFocused } from '../../../common/contextkeys.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { Action2, MenuId, registerAction2 } from '../../../../platform/actions/common/actions.js';
 import { IViewsService } from '../../../services/views/common/viewsService.js';
 import { ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
@@ -33,6 +33,7 @@ import { IExecutionHistoryService } from '../../../services/positronHistory/comm
 import { CodeAttributionSource, IConsoleCodeAttribution } from '../../../services/positronConsole/common/positronConsoleCodeExecution.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { POSITRON_NOTEBOOK_CELL_EDITOR_FOCUSED } from '../../../services/positronNotebook/browser/ContextKeysManager.js';
+import { getContextFromActiveEditor } from '../../notebook/browser/controller/coreActions.js';
 
 /**
  * Positron console command ID's.
@@ -46,6 +47,7 @@ const enum PositronConsoleCommandId {
 	NavigateInputHistoryDown = 'workbench.action.positronConsole.navigateInputHistoryDown',
 	NavigateInputHistoryUp = 'workbench.action.positronConsole.navigateInputHistoryUp',
 	NavigateInputHistoryUpUsingPrefixMatch = 'workbench.action.positronConsole.navigateInputHistoryUpUsingPrefixMatch',
+	ShowNotebookConsole = 'workbench.action.positronConsole.showNotebookConsole'
 }
 
 /**
@@ -759,4 +761,58 @@ export function registerPositronConsoleActions() {
 			}
 		}
 	});
+
+	/**
+	 * Register the action to show the notebook console.
+	 *
+	 * This will create a new console for the notebook if it doesn't have one,
+	 * and will raise and focus the existing console if one exists
+	 */
+	registerAction2(class extends Action2 {
+		/**
+		 * Constructor.
+		 */
+		constructor() {
+			super({
+				id: PositronConsoleCommandId.ShowNotebookConsole,
+				title: {
+					value: localize('workbench.action.positronConsole.showNotebookConsole', "Show Notebook Console"),
+					original: 'Show Notebook Console'
+				},
+				f1: true,
+				category,
+				menu: [
+					{
+						// Add an entry to the notebook toolbar to show the
+						// notebook console
+						id: MenuId.NotebookToolbar,
+						group: 'notebookConsole',
+						when: ContextKeyExpr.equals('config.notebook.globalToolbar', true),
+						order: 1
+					}
+				]
+			});
+		}
+
+		/**
+		 * Runs action and creates the notebook console.
+		 *
+		 * @param accessor The services accessor.
+		 */
+		async run(accessor: ServicesAccessor) {
+			// Get services
+			const positronConsoleService = accessor.get(IPositronConsoleService);
+			const editorService = accessor.get(IEditorService);
+			const notificationService = accessor.get(INotificationService);
+
+			// Figure out the URI of the active notebook and tell the console
+			// service to start a console attached to the appropriate session
+			const context = getContextFromActiveEditor(editorService);
+			if (context) {
+				positronConsoleService.showNotebookConsole(context.notebookEditor.textModel.uri, true);
+			} else {
+				notificationService.info(localize('positron.noActiveNotebook', "No active notebook; run this command with a notebook open in an editor to see its console."));
+			}
+		}
+	});
 }

src/vs/workbench/contrib/positronNotebook/browser/ExecuteSelectionInConsoleAction.ts

@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (C) 2025 Posit Software, PBC. All rights reserved.
+ *  Licensed under the Elastic License 2.0. See LICENSE.txt for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize, localize2 } from '../../../../nls.js';
+import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IPositronConsoleService } from '../../../services/positronConsole/browser/interfaces/positronConsoleService.js';
+import { IRuntimeSessionService } from '../../../services/runtimeSession/common/runtimeSessionService.js';
+import { CELL_TITLE_CELL_GROUP_ID, CellToolbarOrder, getContextFromActiveEditor } from '../../notebook/browser/controller/coreActions.js';
+import { executeIcon } from '../../notebook/browser/notebookIcons.js';
+import { NOTEBOOK_EDITOR_ID } from '../../notebook/common/notebookCommon.js';
+import { CodeAttributionSource } from '../../../services/positronConsole/common/positronConsoleCodeExecution.js';
+import { RuntimeCodeExecutionMode } from '../../../services/languageRuntime/common/languageRuntimeService.js';
+import { POSITRON_NOTEBOOK_EDITOR_ID } from '../common/positronNotebookCommon.js';
+import { NOTEBOOK_CELL_TYPE } from '../../notebook/common/notebookContextKeys.js';
+
+export const SELECT_KERNEL_ID_POSITRON = 'positronNotebook.selectKernel';
+
+/**
+ * An action that executes the selected text in a notebook cell in the
+ * associated console for the notebook.
+ */
+export class ExecuteSelectionInConsoleAction extends Action2 {
+
+	constructor() {
+		super({
+			id: 'positronNotebook.executeSelectionInConsole',
+			category: localize2('notebook.category', 'Notebook'),
+			title: localize2('positronNotebookActions.executeSelectionInConsole', 'Execute Selection in Console'),
+			icon: executeIcon,
+			f1: true,
+			// Only enable if the active editor is a notebook (Positron or built-in)
+			precondition: ContextKeyExpr.or(
+				ContextKeyExpr.equals('activeEditor', POSITRON_NOTEBOOK_EDITOR_ID),
+				ContextKeyExpr.equals('activeEditor', NOTEBOOK_EDITOR_ID),
+			),
+			// Show in the cell context menu, but only for code cells and when there's a selection
+			menu: [
+				{
+					id: MenuId.NotebookCellTitle,
+					// We intentionally re-use the "Execute Cell and Below"
+					// order so that this appears next to it in the menu w/o us
+					// needing to reorder any menus from upstream
+					order: CellToolbarOrder.ExecuteCellAndBelow,
+					group: CELL_TITLE_CELL_GROUP_ID,
+					when: ContextKeyExpr.and(
+						NOTEBOOK_CELL_TYPE.isEqualTo('code'),
+						EditorContextKeys.hasNonEmptySelection
+					),
+				}
+			]
+		});
+	}
+
+	async run(accessor: ServicesAccessor): Promise<boolean> {
+		// Get services
+		const positronConsoleService = accessor.get(IPositronConsoleService);
+		const editorService = accessor.get(IEditorService);
+		const runtimeSessionService = accessor.get(IRuntimeSessionService);
+		const logService = accessor.get(ILogService);
+		const notificationService = accessor.get(INotificationService);
+
+		// Figure out the URI of the active notebook
+		const context = getContextFromActiveEditor(editorService);
+		if (!context) {
+			// This should never happen because of the precondition on the
+			// action, but log if it does
+			logService.warn('No active notebook editor found when trying to execute selection in console');
+			return false;
+		}
+		const notebookUri = context.notebookEditor.textModel.uri;
+
+		// Look up the session for the notebook
+		const session = runtimeSessionService.getNotebookSessionForNotebookUri(notebookUri);
+		if (!session) {
+			// Just warn and return if there's no session; this should be rare.
+			// If we wanted to be nicer here, we could try to orchestrate an
+			// auto-start.
+			notificationService.warn(localize('positron.noNotebookSession', "Cannot execute selection; no interpreter session is running for notebook {0}", notebookUri.toString()));
+			return false;
+		}
+
+		// Show (and possibly create) the console for the notebook
+		positronConsoleService.showNotebookConsole(notebookUri, false /*focus*/);
+
+		// Figure out the selected text, or the entire line if no selection
+		const selectedText = this.getSelectedText(editorService);
+		if (!selectedText) {
+			// It's weird to run this with nothing selected and no active line,
+			// but just log and return
+			logService.warn('Execute Selection in Console: No text selected and no active line found');
+			return false;
+		}
+
+		// Ask the console service to execute the text
+		positronConsoleService.executeCode(
+			session.runtimeMetadata.languageId,
+			session.sessionId,
+			selectedText,
+			{ source: CodeAttributionSource.Interactive },
+			false, // focus
+			true, // allow incomplete
+			RuntimeCodeExecutionMode.Interactive
+		);
+		return true;
+	}
+
+	/**
+	 * Gets the selected text from the active editor, or the entire line if no selection
+	 */
+	private getSelectedText(editorService: IEditorService): string | null {
+		let editor = editorService.activeTextEditorControl;
+		if (!editor) {
+			return null;
+		}
+
+		// Ensure we have a code editor with a model
+		if (!isCodeEditor(editor) || !editor.hasModel()) {
+			return null;
+		}
+
+		const selection = editor.getSelection();
+		if (!selection) {
+			return null;
+		}
+
+		const model = editor.getModel();
+
+		// If there's a selection, get the selected text
+		if (!selection.isEmpty()) {
+			return model.getValueInRange(selection);
+		} else {
+			// No selection - get the entire line where the cursor is
+			const position = selection.getStartPosition();
+			const lineContent = model.getLineContent(position.lineNumber);
+			return lineContent.trim() || null;
+		}
+	}
+}
+

src/vs/workbench/contrib/positronNotebook/browser/PositronNotebookHeader.tsx

@@ -28,6 +28,11 @@ export function PositronNotebookHeader({ notebookInstance }: { notebookInstance:
 			fullLabel={(() => localize('clearAllCellOutputsLong', 'Clear All Cell Outputs'))()}
 			label={(() => localize('clearAllCellOutputsShort', 'Clear Outputs'))()}
 			onClick={() => { notebookInstance.clearAllCellOutputs(); }} />
+		<IconedButton
+			codicon='terminal'
+			fullLabel={(() => localize('showNotebookConsoleLong', 'Create or Focus Notebook Console'))()}
+			label={(() => localize('showNotebookConsole', 'Show Console'))()}
+			onClick={() => { notebookInstance.showNotebookConsole(); }} />
 		<div style={{ marginLeft: 'auto' }}></div>
 		<AddCodeCellButton index={0} notebookInstance={notebookInstance} />
 		<AddMarkdownCellButton index={0} notebookInstance={notebookInstance} />