Add support for discovering, and running, R in Pixi environments (#11026)

Replaces #10995, and addresses
#3724.

#### New Features

- Experimental support for Pixi R installations in Positron; enable in
Settings. (#3724)

#### Bug Fixes

- N/A


### QA Notes

This change should be tested on Windows and at least one other OS, since
it has a fair bit of Windows specific code, and it also refactors some
Conda code so it's worth making sure that still works, too.

---------

Co-authored-by: Wolf Vollprecht <[email protected]>

Author: jmcphers

extensions/positron-r/package.json

@@ -286,6 +286,16 @@
             ],
             "markdownDescription": "%r.configuration.interpreters.condaDiscovery.markdownDescription%"
           },
+          "positron.r.interpreters.pixiDiscovery": {
+            "scope": "resource",
+            "type": "boolean",
+            "default": false,
+            "tags": [
+              "interpreterSettings",
+              "experimental"
+            ],
+            "markdownDescription": "%r.configuration.interpreters.pixiDiscovery.markdownDescription%"
+          },
           "positron.r.kernel.path": {
             "scope": "window",
             "type": "string",

extensions/positron-r/package.nls.json

@@ -39,6 +39,7 @@
 	"r.configuration.interpreters.override.markdownDescription": "List of absolute paths to R binaries or folders containing R installations to override the list of available R interpreters. Only the interpreters found at the specified paths will be displayed in the Positron UI.\n\nThis setting takes precedence over the `#positron.r.customBinaries#`, `#positron.r.customRootFolders#`, and `#positron.r.interpreters.exclude#` settings.\n\nExample: On Linux or Mac, add `/custom/location/R/4.3.0/bin/R` to include only this specific installation, or `/custom/location` to include only R installations found within the directory.\n\nRequires a restart to take effect.",
 	"r.configuration.interpreters.default.markdownDescription": "Absolute path to the default R binary to use for new workspaces. This setting no longer applies once you select an R interpreter for the workspace.\n\nExample: On Linux, add `/custom/location/R/4.3.0/bin/R` to set the default interpreter to the specific R binary.\n\nRequires a restart to take effect.",
 	"r.configuration.interpreters.condaDiscovery.markdownDescription": "Enable discovery of R installations within conda/mamba environments. Support for conda environments in Positron is experimental and may not work correctly in all cases. When enabled, R installations found in conda environments will be available for selection, and the conda environment will be automatically activated when starting an R console.\n\nRequires a restart to take effect.",
+	"r.configuration.interpreters.pixiDiscovery.markdownDescription": "Enable discovery of R installations within Pixi environments. Pixi is a package manager that uses conda packages with project-local environments stored in `.pixi/envs/`. When enabled, R installations found in Pixi environments within open workspaces will be available for selection, and the Pixi environment will be automatically activated when starting an R console.\n\nRequires a restart to take effect.",
 	"r.configuration.kernelPath.description": "Path on disk to the ARK kernel executable; use this to override the default (embedded) kernel. Note that this is not the path to R.",
 	"r.configuration.tracing.description": "Traces the communication between VS Code and the language server",
 	"r.configuration.tracing.off.description": "No tracing.",

extensions/positron-r/src/kernel-spec.ts

@@ -13,6 +13,8 @@ import { JupyterKernelSpec } from './positron-supervisor';
 import { getArkKernelPath } from './kernel';
 import { EXTENSION_ROOT_DIR } from './constants';
 import { findCondaExe } from './provider-conda';
+import { PackagerMetadata, isPixiMetadata, isCondaMetadata } from './r-installation';
+import { findPixiExe } from './provider-pixi';
 import { LOGGER } from './extension';
 
 /**
@@ -62,11 +64,12 @@ function setSpeculativeCondaEnvVars(env: Record<string, string>, envPath: string
  * variables are used instead.
  *
  * @param env The environment record to populate with conda variables
+ * @param rBinaryPath The R binary path to add to PATH
  * @param envPath The path to the conda environment
  * @param envName The name of the conda environment
  * @returns A promise that resolves when activation is complete
  */
-async function captureCondaEnvVarsWindows(env: Record<string, string>, envPath: string, envName: string): Promise<void> {
+async function captureCondaEnvVarsWindows(env: Record<string, string>, rBinaryPath: string, envPath: string, envName: string): Promise<void> {
 	const condaExe = findCondaExe(envPath);
 	if (!condaExe) {
 		LOGGER.error('Could not find conda.exe for environment:', envPath);
@@ -109,9 +112,20 @@ async function captureCondaEnvVarsWindows(env: Record<string, string>, envPath:
 						LOGGER.trace(`Skipping line without '=': ${line}`);
 						continue;
 					}
-					const key = trimmed.substring(0, eqIndex).trim();
-					const value = trimmed.substring(eqIndex + 1).trim();
-					env[key] = value;
+					let envKey = trimmed.substring(0, eqIndex).trim();
+					let envValue = trimmed.substring(eqIndex + 1).trim();
+					if (process.platform === 'win32') {
+						// On Windows, add the R binary path to PATH, if it is not already present
+						envKey = envKey.toUpperCase();
+						if (rBinaryPath &&
+							process.platform === 'win32' &&
+							envKey === 'PATH' &&
+							!envValue.includes(path.dirname(rBinaryPath))) {
+							envValue = path.dirname(rBinaryPath) + ';' + envValue;
+						}
+					}
+					LOGGER.trace(`Set ${envKey}=${envValue}`);
+					env[envKey] = envValue;
 				}
 			} else {
 				throw new Error(`Activation script not found at ${scriptPath}`);
@@ -165,6 +179,117 @@ async function captureCondaEnvVarsWindows(env: Record<string, string>, envPath:
 	await activationPromise;
 }
 
+/**
+ * JSON output format from `pixi shell-hook --json`
+ */
+interface PixiShellHookJson {
+	environment_variables: Record<string, string>;
+}
+
+/**
+ * Capture Pixi environment variables by running `pixi shell-hook --json` and parsing
+ * the JSON output. This is more reliable than parsing shell scripts.
+ *
+ * @param env The environment record to populate with pixi variables
+ * @param manifestPath The path to the pixi manifest file (pixi.toml or pyproject.toml)
+ * @param envName The name of the pixi environment
+ * @returns A promise that resolves when activation is complete
+ */
+async function capturePixiEnvVars(
+	env: Record<string, string>,
+	rBinaryPath: string,
+	manifestPath: string,
+	envName?: string
+): Promise<void> {
+	const pixiExe = await findPixiExe();
+	if (!pixiExe) {
+		// This shouldn't happen since we discovered the environment via pixi
+		LOGGER.error('Could not find pixi executable for environment activation');
+		return;
+	}
+
+	let cancelled = false;
+
+	const doActivation = (): void => {
+		try {
+			let command = `"${pixiExe}" shell-hook --manifest-path "${manifestPath}" --json`;
+			if (envName && envName !== 'default') {
+				command += ` --environment "${envName}"`;
+			}
+			LOGGER.debug(`Running to capture Pixi variables: ${command}`);
+			const output = execSync(command, { encoding: 'utf8', timeout: 30000 });
+
+			if (cancelled) {
+				throw new Error('Pixi activation cancelled by user');
+			}
+
+			// Parse JSON output
+			const hookData: PixiShellHookJson = JSON.parse(output);
+
+			// Apply environment variables
+			for (const [key, value] of Object.entries(hookData.environment_variables)) {
+				// On Windows, convert key to uppercase for consistency
+				const envKey = process.platform === 'win32' ? key.toUpperCase() : key;
+				let envValue = value;
+
+				// On Windows, add the R binary path to PATH. Pixi does not add this
+				// but it's needed for R to find its DLLs.
+				if (process.platform === 'win32' && envKey === 'PATH') {
+					envValue = path.dirname(rBinaryPath) + ';' + envValue;
+				}
+				env[envKey] = envValue;
+				LOGGER.trace(`Set ${envKey}=${envValue}`);
+			}
+		} catch (e) {
+			LOGGER.error('Failed to capture pixi environment variables:', e.message);
+			if (e.stdout) {
+				LOGGER.error('stdout:', e.stdout);
+			}
+			if (e.stderr) {
+				LOGGER.error('stderr:', e.stderr);
+			}
+			// Don't fall back to speculative values - if pixi shell-hook fails,
+			// the R session will start without environment activation.
+			// R_HOME is already set, so basic functionality should still work.
+		}
+	};
+
+	const activationPromise = new Promise<void>((resolve) => {
+		doActivation();
+		resolve();
+	});
+
+	// Show progress toast if activation takes longer than 2 seconds
+	const progressDelay = 2000;
+	let showProgress = true;
+
+	const timeoutPromise = new Promise<void>((resolve) => {
+		setTimeout(() => {
+			if (showProgress) {
+				vscode.window.withProgress(
+					{
+						location: vscode.ProgressLocation.Notification,
+						title: vscode.l10n.t("Activating Pixi environment '{0}'...", envName || 'default'),
+						cancellable: true
+					},
+					async (_progress, token) => {
+						token.onCancellationRequested(() => {
+							cancelled = true;
+							LOGGER.info('User cancelled pixi activation');
+						});
+						await activationPromise;
+					}
+				);
+			}
+			resolve();
+		}, progressDelay);
+	});
+
+	await Promise.race([activationPromise, timeoutPromise]);
+	showProgress = false;
+	await activationPromise;
+}
+
 /**
  * Create a new Jupyter kernel spec.
  *
@@ -180,7 +305,11 @@ export async function createJupyterKernelSpec(
 	rHomePath: string,
 	runtimeName: string,
 	sessionMode: positron.LanguageRuntimeSessionMode,
-	options?: { rBinaryPath?: string; rArchitecture?: string; condaEnvironmentPath?: string }): Promise<JupyterKernelSpec> {
+	options?: {
+		rBinaryPath?: string;
+		rArchitecture?: string;
+		packagerMetadata?: PackagerMetadata;
+	}): Promise<JupyterKernelSpec> {
 
 	// Path to the kernel executable
 	const kernelPath = getArkKernelPath({
@@ -223,22 +352,32 @@ export async function createJupyterKernelSpec(
 		env['DYLD_LIBRARY_PATH'] = rHomePath + '/lib';
 	}
 
-	// If this R is from a conda environment, activate the conda environment
+	// If this R is from a packager environment (conda or pixi), activate it
 	// to ensure that compilation tools and other dependencies are available
 	let startup_command: string | undefined = undefined;
-	if (options?.condaEnvironmentPath) {
-		const envPath = options.condaEnvironmentPath;
+	const packagerMetadata = options?.packagerMetadata;
+
+	if (packagerMetadata && isCondaMetadata(packagerMetadata)) {
+		const envPath = packagerMetadata.environmentPath;
 		const envName = path.basename(envPath);
 		if (process.platform === 'win32') {
 			// On Windows, capture environment variables directly instead of using a startup command;
 			// the startup command approach is unreliable on Windows
-			await captureCondaEnvVarsWindows(env, envPath, envName);
+			await captureCondaEnvVarsWindows(env, options?.rBinaryPath, envPath, envName);
 		} else {
 			// On Unix-like systems, use conda activate as startup command
 			startup_command = 'conda activate ' + envPath;
 		}
 	}
 
+	// If this R is from a pixi environment, activate the pixi environment
+	// to ensure that compilation tools and other dependencies are available
+	if (packagerMetadata && isPixiMetadata(packagerMetadata)) {
+		// For Pixi, we capture environment variables directly on all platforms
+		// since pixi shell-hook --json provides a consistent interface
+		await capturePixiEnvVars(env, options?.rBinaryPath, packagerMetadata.manifestPath, packagerMetadata.environmentName);
+	}
+
 	// R script to run on session startup
 	const startupFile = path.join(EXTENSION_ROOT_DIR, 'resources', 'scripts', 'startup.R');
 
@@ -258,13 +397,13 @@ export async function createJupyterKernelSpec(
 	}
 
 	// On Windows, we need to tell ark to use a different DLL search path when
-	// dealing with Conda environments. Conda R installations have DLL
+	// dealing with Conda/Pixi environments. These R installations have DLL
 	// dependencies in non-standard locations. These locations are part of the
-	// PATH set during Conda activation, but by default Ark has a more limited set
+	// PATH set during environment activation, but by default Ark has a more limited set
 	// of directories it searches for DLLs. The `--standard-dll-search-order`
-	// option tells Ark  to use Windows' standard DLL search path, which includes
+	// option tells Ark to use Windows' standard DLL search path, which includes
 	// the PATH entries.
-	if (process.platform === 'win32' && options?.condaEnvironmentPath) {
+	if (process.platform === 'win32' && packagerMetadata) {
 		argv.push('--standard-dll-search-order');
 	}
 

extensions/positron-r/src/provider-conda.ts

@@ -108,7 +108,7 @@ export async function discoverCondaBinaries(): Promise<RBinary[]> {
 					rBinaries.push({
 						path: rPath,
 						reasons: [ReasonDiscovered.CONDA],
-						condaEnvironmentPath: envPath
+						packagerMetadata: { environmentPath: envPath }
 					});
 					break;
 				}