wip

Author: austin3dickey

extensions/positron-supervisor/src/KallichoreSession.ts

@@ -158,6 +158,11 @@ export class KallichoreSession implements JupyterLanguageRuntimeSession {
 	 */
 	private _activeSession: ActiveSession | undefined;
 
+	/**
+	 * The working directory provided when starting the session, if any.
+	 */
+	private _providedWorkingDirectory: string | undefined;
+
 	/**
 	 * The message header for the current requests if any is active.  This is
 	 * used for input requests (e.g. from `readline()` in R) Concurrent requests
@@ -340,18 +345,23 @@ export class KallichoreSession implements JupyterLanguageRuntimeSession {
 		this._kernelSpec = kernelSpec;
 		const varActions = await this.buildEnvVarActions(false);
 
-		// Prepare the working directory; use the workspace root if available,
-		// otherwise the home directory
-		let workingDir = vscode.workspace.workspaceFolders?.[0].uri.fsPath || os.homedir();
-
-		// If we have a notebook URI, use its parent directory as the working
-		// directory instead. Note that not all notebooks have valid on-disk
-		// URIs since they may be transient or not yet saved; for these, we fall
-		// back to the workspace root or home directory.
-		if (this.metadata.notebookUri?.fsPath) {
-			const notebookPath = this.metadata.notebookUri.fsPath;
-			if (fs.existsSync(notebookPath)) {
-				workingDir = path.dirname(notebookPath);
+		// Prepare the working directory; use the configured working directory if provided,
+		// otherwise use the workspace root if available, otherwise the home directory
+		let workingDir = this._providedWorkingDirectory;
+
+		if (!workingDir) {
+			// Default to workspace root or home directory
+			workingDir = vscode.workspace.workspaceFolders?.[0].uri.fsPath || os.homedir();
+
+			// If we have a notebook URI, use its parent directory as the working
+			// directory instead. Note that not all notebooks have valid on-disk
+			// URIs since they may be transient or not yet saved; for these, we fall
+			// back to the workspace root or home directory.
+			if (this.metadata.notebookUri?.fsPath) {
+				const notebookPath = this.metadata.notebookUri.fsPath;
+				if (fs.existsSync(notebookPath)) {
+					workingDir = path.dirname(notebookPath);
+				}
 			}
 		}
 
@@ -1034,7 +1044,10 @@ export class KallichoreSession implements JupyterLanguageRuntimeSession {
 	 *
 	 * @returns The kernel info for the session.
 	 */
-	async start(): Promise<positron.LanguageRuntimeInfo> {
+	async start(workingDirectory?: string): Promise<positron.LanguageRuntimeInfo> {
+		// Store the provided working directory for use during session creation
+		this._providedWorkingDirectory = workingDirectory;
+
 		// If this session needs to be started by an external provider, do that
 		// instead of asking the supervisor to start it.
 		if (this._kernelSpec?.startKernel) {

src/positron-dts/positron.d.ts

@@ -1064,8 +1064,9 @@ declare module 'positron' {
 		 * If the runtime fails to start for any reason, the Thenable should reject with an error
 		 * object containing a `message` field with a human-readable error message and an optional
 		 * `details` field with additional information.
+		 * @param workingDirectory Optional working directory for the runtime session
 		 */
-		start(): Thenable<LanguageRuntimeInfo>;
+		start(workingDirectory?: string): Thenable<LanguageRuntimeInfo>;
 
 		/**
 		 * Interrupt the runtime; returns a Thenable that resolves when the interrupt has been

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

@@ -15,6 +15,10 @@ import { IModelService } from '../../../../editor/common/services/model.js';
 import { ILanguageSelection, ILanguageService } from '../../../../editor/common/languages/language.js';
 import { ITextModelContentProvider, ITextModelService } from '../../../../editor/common/services/resolverService.js';
 import * as nls from '../../../../nls.js';
+// --- Start Positron ---
+// eslint-disable-next-line no-duplicate-imports
+import { ConfigurationScope } from '../../../../platform/configuration/common/configurationRegistry.js';
+// --- End Positron ---
 import { Extensions, IConfigurationPropertySchema, IConfigurationRegistry } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
 import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
@@ -1311,6 +1315,12 @@ configurationRegistry.registerConfiguration({
 			type: 'string',
 			default: '',
 			tags: ['notebookLayout']
+		},
+		[NotebookSetting.workingDirectory]: {
+			markdownDescription: nls.localize('notebook.workingDirectory', "Default working directory for notebook kernels. Supports variables like `${workspaceFolder}`. When empty, uses the notebook file's directory."),
+			type: 'string',
+			default: '',
+			scope: ConfigurationScope.RESOURCE
 		}
 	}
 });

src/vs/workbench/contrib/notebook/common/notebookCommon.ts

@@ -1065,6 +1065,7 @@ export const NotebookSetting = {
 	outputBackupSizeLimit: 'notebook.backup.sizeLimit',
 	multiCursor: 'notebook.multiCursor.enabled',
 	markupFontFamily: 'notebook.markup.fontFamily',
+	workingDirectory: 'notebook.workingDirectory',
 } as const;
 
 export const enum CellStatusbarAlignment {

src/vs/workbench/services/positronHistory/test/common/executionHistoryService.test.ts

@@ -15,7 +15,7 @@ import { IRuntimeAutoStartEvent, IRuntimeStartupService, ISessionRestoreFailedEv
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 import { ExecutionHistoryService } from '../../common/executionHistory.js';
 import { IWorkspace, IWorkspaceContextService, IWorkspaceFoldersWillChangeEvent } from '../../../../../platform/workspace/common/workspace.js';
-import { ILanguageRuntimeExit, ILanguageRuntimeMetadata, ILanguageRuntimeSessionState, IRuntimeManager, LanguageRuntimeSessionLocation, LanguageRuntimeSessionMode, LanguageRuntimeStartupBehavior, RuntimeExitReason, RuntimeState } from '../../../../services/languageRuntime/common/languageRuntimeService.js';
+import { ILanguageRuntimeExit, ILanguageRuntimeInfo, ILanguageRuntimeMetadata, ILanguageRuntimeSessionState, IRuntimeManager, LanguageRuntimeSessionLocation, LanguageRuntimeSessionMode, LanguageRuntimeStartupBehavior, RuntimeExitReason, RuntimeState } from '../../../../services/languageRuntime/common/languageRuntimeService.js';
 import { TestConfigurationService } from '../../../../../platform/configuration/test/common/testConfigurationService.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
 import { Emitter } from '../../../../../base/common/event.js';
@@ -519,7 +519,7 @@ class TestLanguageRuntimeSession extends Disposable implements ILanguageRuntimeS
 		throw new Error('Method not implemented.');
 	}
 
-	start(_showBanner?: boolean): Promise<any> {
+	start(_workingDirectory?: string): Promise<ILanguageRuntimeInfo> {
 		throw new Error('Method not implemented.');
 	}
 

src/vs/workbench/services/runtimeSession/common/runtimeSession.ts

@@ -27,6 +27,9 @@ import { INotificationService, Severity } from '../../../../platform/notificatio
 import { localize } from '../../../../nls.js';
 import { UiClientInstance } from '../../languageRuntime/common/languageRuntimeUiClient.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IConfigurationResolverService } from '../../configurationResolver/common/configurationResolver.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { NotebookSetting } from '../../../contrib/notebook/common/notebookCommon.js';
 
 /**
  * The maximum number of active sessions a user can have running at a time.
@@ -170,7 +173,9 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		@IExtensionService private readonly _extensionService: IExtensionService,
 		@IStorageService private readonly _storageService: IStorageService,
 		@IUpdateService private readonly _updateService: IUpdateService,
-		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
+		@IConfigurationResolverService private readonly _configurationResolverService: IConfigurationResolverService,
+		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService
 	) {
 
 		super();
@@ -387,6 +392,44 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		return Array.from(this._activeSessionsBySessionId.values());
 	}
 
+	/**
+	 * Resolves the working directory configuration with variable substitution.
+	 *
+	 * @param notebookUri The URI of the notebook, if any, for resource-scoped configuration
+	 * @returns The resolved working directory or undefined if not configured
+	 */
+	private async resolveWorkingDirectory(notebookUri?: URI): Promise<string | undefined> {
+		// Get the working directory configuration
+		const configValue = this._configurationService.getValue<string>(
+			NotebookSetting.workingDirectory,
+			notebookUri ? { resource: notebookUri } : {}
+		);
+
+		// If no configuration value is set, return undefined
+		if (!configValue || configValue.trim() === '') {
+			return undefined;
+		}
+
+		// Get the workspace folder for variable resolution
+		const workspaceFolder = notebookUri
+			? this._workspaceContextService.getWorkspaceFolder(notebookUri)
+			: this._workspaceContextService.getWorkspace().folders[0];
+
+		try {
+			// Resolve variables in the configuration value
+			const resolvedValue = await this._configurationResolverService.resolveAsync(
+				workspaceFolder || undefined,
+				configValue
+			);
+
+			return resolvedValue;
+		} catch (error) {
+			// Log the error and return the original value as fallback
+			this._logService.warn(`Failed to resolve working directory variables in '${configValue}':`, error);
+			return configValue;
+		}
+	}
+
 	/**
 	 * Select a session for the provided runtime.
 	 *
@@ -466,6 +509,9 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 			}
 		}
 
+		// Resolve the working directory configuration
+		const workingDirectory = await this.resolveWorkingDirectory(notebookUri);
+
 		// Wait for the selected runtime to start.
 		await this.startNewRuntimeSession(
 			runtime.runtimeId,
@@ -474,7 +520,8 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 			notebookUri,
 			source,
 			startMode,
-			true
+			true,
+			workingDirectory
 		);
 	}
 
@@ -567,6 +614,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 	 * @param source The source of the request to start the runtime.
 	 * @param startMode The mode in which to start the runtime.
 	 * @param activate Whether to activate/focus the session after it is started.
+	 * @param workingDirectory The working directory to use for the session, if any.
 	 */
 	async startNewRuntimeSession(
 		runtimeId: string,
@@ -575,7 +623,8 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		notebookUri: URI | undefined,
 		source: string,
 		startMode = RuntimeStartMode.Starting,
-		activate: boolean): Promise<string> {
+		activate: boolean,
+		workingDirectory?: string): Promise<string> {
 		// See if we are already starting the requested session. If we
 		// are, return the promise that resolves when the session is ready to
 		// use. This makes it possible for multiple requests to start the same
@@ -611,7 +660,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		this._logService.info(
 			`Starting session for language runtime ` +
 			`${formatLanguageRuntimeMetadata(languageRuntime)} (Source: ${source})`);
-		return this.doCreateRuntimeSession(languageRuntime, sessionName, sessionMode, source, startMode, activate, notebookUri);
+		return this.doCreateRuntimeSession(languageRuntime, sessionName, sessionMode, source, startMode, activate, notebookUri, workingDirectory);
 	}
 
 	/**
@@ -742,7 +791,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		}
 
 		// Actually reconnect the session.
-		await this.doStartRuntimeSession(session, sessionManager, RuntimeStartMode.Reconnecting, activate);
+		await this.doStartRuntimeSession(session, sessionManager, RuntimeStartMode.Reconnecting, activate, undefined);
 
 		return sessionMetadata.sessionId;
 
@@ -1061,7 +1110,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 			// Restart the working directory in the same directory as the session.
 			if (session.getRuntimeState() === RuntimeState.Exited) {
 				// Do a start, behind the scenes
-				await session.start();
+				await session.start(activeSession.workingDirectory);
 			} else {
 				await session.restart(activeSession.workingDirectory);
 			}
@@ -1486,7 +1535,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 			}
 		}
 
-		return this.doCreateRuntimeSession(metadata, metadata.runtimeName, sessionMode, source, RuntimeStartMode.Starting, activate, notebookUri);
+		return this.doCreateRuntimeSession(metadata, metadata.runtimeName, sessionMode, source, RuntimeStartMode.Starting, activate, notebookUri, undefined);
 	}
 
 	/**
@@ -1499,6 +1548,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 	 * @param startMode The mode in which to start the runtime.
 	 * @param activate Whether to activate/focus the session after it is started.
 	 * @param notebookDocument The notebook document to attach to the session, if any.
+	 * @param workingDirectory The working directory to use for the session, if any.
 	 *
 	 * Returns a promise that resolves with the session ID when the runtime is
 	 * ready to use.
@@ -1509,7 +1559,8 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 		source: string,
 		startMode: RuntimeStartMode,
 		activate: boolean,
-		notebookUri?: URI): Promise<string> {
+		notebookUri?: URI,
+		workingDirectory?: string): Promise<string> {
 		this.setStartingSessionMaps(sessionMode, runtimeMetadata, notebookUri);
 
 		// Create a promise that resolves when the runtime is ready to use, if there isn't already one.
@@ -1560,7 +1611,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 
 		// Actually start the session.
 		try {
-			await this.doStartRuntimeSession(session, sessionManager, startMode, activate);
+			await this.doStartRuntimeSession(session, sessionManager, startMode, activate, workingDirectory);
 			startPromise.complete(sessionId);
 		} catch (err) {
 			startPromise.error(err);
@@ -1576,11 +1627,13 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 	 * @param manager The session manager for the session.
 	 * @param startMode The mode in which the session is starting.
 	 * @param activate Whether to activate/focus the session after it is started.
+	 * @param workingDirectory The working directory to use for the session, if any.
 	 */
 	private async doStartRuntimeSession(session: ILanguageRuntimeSession,
 		manager: ILanguageRuntimeSessionManager,
 		startMode: RuntimeStartMode,
-		activate: boolean):
+		activate: boolean,
+		workingDirectory?: string):
 		Promise<void> {
 		// Fire the onWillStartRuntime event.
 		const evt: IRuntimeSessionWillStartEvent = {
@@ -1595,7 +1648,7 @@ export class RuntimeSessionService extends Disposable implements IRuntimeSession
 
 		try {
 			// Attempt to start, or reconnect to, the session.
-			await session.start();
+			await session.start(workingDirectory);
 
 			// The session has started. Move it from the starting runtimes to the
 			// running runtimes.

src/vs/workbench/services/runtimeSession/common/runtimeSessionService.ts

@@ -202,7 +202,7 @@ export interface ILanguageRuntimeSession extends IDisposable {
 	 */
 	setWorkingDirectory(directory: string): Thenable<void>;
 
-	start(): Thenable<ILanguageRuntimeInfo>;
+	start(workingDirectory?: string): Thenable<ILanguageRuntimeInfo>;
 
 	/** Interrupt the runtime */
 	interrupt(): void;
@@ -408,6 +408,7 @@ export interface IRuntimeSessionService {
 	 * @param startMode The mode in which to start the runtime.
 	 * @param activate Whether to activate/focus the session after it is
 	 * started.
+	 * @param workingDirectory Optional working directory for the runtime session.
 	 *
 	 * Returns a promise that resolves to the session ID of the new session.
 	 */
@@ -418,7 +419,8 @@ export interface IRuntimeSessionService {
 		notebookUri: URI | undefined,
 		source: string,
 		startMode: RuntimeStartMode,
-		activate: boolean): Promise<string>;
+		activate: boolean,
+		workingDirectory?: string): Promise<string>;
 
 	/**
 	 * Validates a persisted runtime session before reconnecting to it.

src/vs/workbench/services/runtimeSession/test/common/runtimeSession.test.ts

@@ -19,6 +19,7 @@ import { TestLanguageRuntimeSession, waitForRuntimeState } from './testLanguageR
 import { createRuntimeServices, createTestLanguageRuntimeMetadata, startTestLanguageRuntimeSession } from './testRuntimeSessionService.js';
 import { TestRuntimeSessionManager } from '../../../../test/common/positronWorkbenchTestServices.js';
 import { TestWorkspaceTrustManagementService } from '../../../../test/common/workbenchTestServices.js';
+import { NotebookSetting } from '../../../../../workbench/contrib/notebook/common/notebookCommon.js';
 
 type IStartSessionTask = (runtime: ILanguageRuntimeMetadata) => Promise<TestLanguageRuntimeSession>;
 
@@ -1182,4 +1183,45 @@ suite('Positron - RuntimeSessionService', () => {
 		assert.strictEqual(session.dynState.sessionName, newName, 'Session name should be updated correctly');
 		assert.strictEqual(otherSession.dynState.sessionName, runtime.runtimeName, 'Other session name should remain unchanged');
 	});
+
+	test('working directory configuration is passed to session start', async () => {
+		// Set working directory configuration
+		const testWorkingDir = '/test/working/directory';
+		configService.setUserConfiguration(NotebookSetting.workingDirectory, testWorkingDir);
+
+		// Create session and verify working directory is passed
+		const session = await startConsole(runtime);
+		await waitForRuntimeState(session, RuntimeState.Ready);
+
+		// Verify that the session received the working directory
+		const startCall = sinon.spy(session, 'start');
+		// For this test, we need to restart to verify the parameter passing
+		await runtimeSessionService.restartSession(session.sessionId, 'test');
+		await waitForRuntimeState(session, RuntimeState.Ready);
+
+		// Check that start was called with the working directory
+		sinon.assert.calledWith(startCall, testWorkingDir);
+	});
+
+	test('working directory configuration is resource-scoped for notebooks', async () => {
+		const testWorkingDir = '/test/notebook/directory';
+		const notebookUri = URI.file('/path/to/test.ipynb');
+
+		// Set resource-scoped working directory configuration
+		configService.setUserConfiguration(NotebookSetting.workingDirectory, testWorkingDir, notebookUri);
+
+		// Start a notebook session
+		await runtimeSessionService.selectRuntime(runtime.runtimeId, 'test', notebookUri);
+		const session = runtimeSessionService.getNotebookSessionForNotebookUri(notebookUri);
+		assert.ok(session, 'Notebook session should be created');
+
+		await waitForRuntimeState(session, RuntimeState.Ready);
+
+		// Verify working directory was applied (by checking that the start method was called correctly)
+		const startSpy = sinon.spy(session, 'start');
+		await runtimeSessionService.restartSession(session.sessionId, 'test');
+		await waitForRuntimeState(session, RuntimeState.Ready);
+
+		sinon.assert.calledWith(startSpy, testWorkingDir);
+	});
 });